Add lean source and binary files (part 11)

lean/OAI/Analysis/BackwardIntertwiners/CoefficientSupport.lean

@@ -0,0 +1,314 @@
+import OAI.Analysis.BackwardIntertwiners.ConvolutionBounds
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+
+def coefficientObstacle (d : ℕ → ℂ) : Set ℕ := {n | 0 < n ∧ d n ≠ 0}
+
+def coefficientEnvelope (d : ℕ → ℂ) : ℕ → ℝ :=
+  convexEnvelope (coefficientObstacle d) (fun n => -Real.log ‖d n‖)
+
+namespace CoefficientEnvelope
+
+variable {d : ℕ → ℂ} {G : ℕ → ℝ}
+variable (hu : ∀ n : ℕ, ∃ k, n < k ∧ d k ≠ 0)
+variable (hG : DiscreteConvex G) (hG0 : G 0 = 0)
+variable (hb : ∀ n, ‖d n‖ ≤ Real.exp (-G n))
+
+include hu in
+lemma unbounded : ∀ n : ℕ, ∃ k, n < k ∧ k ∈ coefficientObstacle d := by
+  intro n
+  obtain ⟨k, hk, hd⟩ := hu n
+  exact ⟨k, hk, by exact ⟨by omega, hd⟩⟩
+
+include hG hG0 hb in
+lemma minorant : G ∈ convexMinorants (coefficientObstacle d) (fun n => -Real.log ‖d n‖) := by
+  refine ⟨hG0, hG, ?_⟩
+  intro n hn
+  have hn0 : 0 < ‖d n‖ := norm_pos_iff.mpr hn.2
+  have hh := Real.log_le_log hn0 (hb n)
+  rw [Real.log_exp] at hh
+  linarith
+
+include hu hG hG0 hb in
+lemma properties :
+    coefficientEnvelope d 0 = 0 ∧ DiscreteConvex (coefficientEnvelope d) ∧
+    (∀ n, G n ≤ coefficientEnvelope d n) ∧
+    (∀ n, ‖d n‖ ≤ Real.exp (-coefficientEnvelope d n)) ∧
+    (∀ n, 0 < coefficientEnvelope d (n+2) - 2*coefficientEnvelope d (n+1) +
+      coefficientEnvelope d n → ‖d (n+1)‖ = Real.exp (-coefficientEnvelope d (n+1))) := by
+  have hm := minorant hG hG0 hb
+  have he : (convexMinorants (coefficientObstacle d) (fun n => -Real.log ‖d n‖)).Nonempty := ⟨G, hm⟩
+  have hU := unbounded hu
+  refine ⟨ConvexEnvelope.zero hU he, ConvexEnvelope.convex hU he,
+    ConvexEnvelope.le_envelope hU hm, ?_, ?_⟩
+  · intro n
+    by_cases hn : n = 0
+    · subst n
+      simpa only [coefficientEnvelope, ConvexEnvelope.zero hU he, hG0] using hb 0
+    · by_cases hd : d n = 0
+      · simp only [hd, norm_zero]; exact (Real.exp_pos _).le
+      · have hbelow := ConvexEnvelope.below he (show n ∈ coefficientObstacle d from ⟨by omega, hd⟩)
+        have hlog : Real.log ‖d n‖ ≤ -coefficientEnvelope d n := by
+          change coefficientEnvelope d n ≤ -Real.log ‖d n‖ at hbelow
+          linarith
+        simpa only [Real.exp_log (norm_pos_iff.mpr hd)] using Real.exp_le_exp.mpr hlog
+  · intro n hn
+    obtain ⟨hd, hc⟩ := ConvexEnvelope.contact hU he n hn
+    change coefficientEnvelope d (n+1) = -Real.log ‖d (n+1)‖ at hc
+    rw [hc, neg_neg, Real.exp_log (norm_pos_iff.mpr hd.2)]
+
+end CoefficientEnvelope
+
+
+
+theorem no_both_unbounded {P Q : ℕ → ℝ} {b c : ℤ → ℂ}
+    (hb : EnvelopeBounds P Q b c) (hP : DiscreteConvex P) (hQ : DiscreteConvex Q)
+    (hP0 : P 0 = 0) (hQ0 : Q 0 = 0) {lam δ : ℝ}
+    (hlam : Real.log 3 < lam) (hδ : lam < δ)
+    (hqp : ∀ᶠ n : ℕ in atTop, δ*(n : ℝ)^2 ≤ P n)
+    (hqq : ∀ᶠ n : ℕ in atTop, δ*(n : ℝ)^2 ≤ Q n)
+    (hbu : ∀ n : ℕ, ∃ k, n < k ∧ b (k : ℤ) ≠ 0)
+    (hcu : ∀ n : ℕ, ∃ k, n < k ∧ c (-(k : ℤ)) ≠ 0)
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) : False := by
+  obtain ⟨hA0, hA, hPA, hcA, hcontactA⟩ :=
+    CoefficientEnvelope.properties hcu hP hP0 hb.c_neg
+  obtain ⟨hB0, hB, hQB, hbB, hcontactB⟩ :=
+    CoefficientEnvelope.properties hbu hQ hQ0 hb.b_pos
+  let A := coefficientEnvelope (fun n => c (-(n : ℤ)))
+  let B := coefficientEnvelope (fun n => b (n : ℤ))
+  apply no_correlation_of_envelopes (A := A) (B := B) (b := b) (c := c)
+    ?_ hA hB hA0 hB0 hlam hδ ?_ ?_ hcontactA hcontactB hz
+  · refine ⟨hbB, ?_, ?_, hcA⟩
+    · intro n
+      exact (hb.b_neg n).trans (Real.exp_le_exp.mpr (hPA n))
+    · intro n
+      exact (hb.c_pos n).trans (Real.exp_le_exp.mpr (hQB n))
+  · filter_upwards [hqp] with n hn using hn.trans (hPA n)
+  · filter_upwards [hqq] with n hn using hn.trans (hQB n)
+
+
+def boundedSideTail (B : ℕ → ℝ) (c : ℤ → ℂ) (h : ℤ) (p k : ℕ) : ℝ :=
+  Real.exp (B p - B (p+k+1)) * ‖c (h+(k:ℤ)+1)‖
+
+lemma boundedSideTail_nonneg (B : ℕ → ℝ) (c : ℤ → ℂ) (h : ℤ) (p k : ℕ) :
+    0 ≤ boundedSideTail B c h p k := mul_nonneg (Real.exp_pos _).le (norm_nonneg _)
+
+lemma boundedSideTail_mono {B : ℕ → ℝ} (hB : DiscreteConvex B)
+    (c : ℤ → ℂ) (h : ℤ) {p₀ p : ℕ} (hpp : p₀ ≤ p) (k : ℕ) :
+    boundedSideTail B c h p k ≤ boundedSideTail B c h p₀ k := by
+  have hh := hB.increment_mono hpp (k+1)
+  unfold boundedSideTail
+  apply mul_le_mul_of_nonneg_right _ (norm_nonneg _)
+  apply Real.exp_le_exp.mpr
+  simp only [← Nat.add_assoc] at hh
+  linarith
+
+lemma boundedSideTail_tendsto {B : ℕ → ℝ} (hB : DiscreteConvex B)
+    (hs : Tendsto (fun n => B (n+1)-B n) atTop atTop)
+    (c : ℤ → ℂ) (h : ℤ) {p₀ : ℕ} (hsum : Summable (boundedSideTail B c h p₀)) :
+    Tendsto (fun p => ∑' k, boundedSideTail B c h p k) atTop (𝓝 0) := by
+  have hpoint (k : ℕ) : Tendsto (fun p => boundedSideTail B c h p k) atTop (𝓝 0) := by
+    have heq : (fun p => boundedSideTail B c h p k) =
+        (fun p => normalizedTailTerm B p k * (Real.exp (-B (k+1)) * ‖c (h+(k:ℤ)+1)‖)) := by
+      funext p
+      unfold boundedSideTail normalizedTailTerm
+      rw [← mul_assoc, ← Real.exp_add]
+      congr 2
+      ring
+    rw [heq]
+    simpa using (hB.tail_term_tendsto hs k).mul_const
+      (Real.exp (-B (k+1)) * ‖c (h+(k:ℤ)+1)‖)
+  have ht := tendsto_tsum_of_dominated_convergence hsum hpoint
+    (show ∀ᶠ p : ℕ in atTop, ∀ k,
+      ‖boundedSideTail B c h p k‖ ≤ boundedSideTail B c h p₀ k from ?_)
+  · simpa using ht
+  · filter_upwards [eventually_ge_atTop p₀] with p hp k
+    rw [Real.norm_eq_abs, abs_of_nonneg (boundedSideTail_nonneg _ _ _ _ _)]
+    exact boundedSideTail_mono hB c h hp k
+
+
+
+theorem no_unbounded_against_min {B : ℕ → ℝ} {b c : ℤ → ℂ}
+    (hB : DiscreteConvex B) (hB0 : B 0 = 0) {δ : ℝ} (hδ : 0 < δ)
+    (hquad : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ B n)
+    (hb : ∀ n : ℕ, ‖b n‖ ≤ Real.exp (-B n))
+    (hc : ∀ n, 0 < B (n+2) - 2*B (n+1) + B n →
+      ‖b ((n+1:ℕ):ℤ)‖ = Real.exp (-B (n+1)))
+    {h : ℤ} (hch : c h ≠ 0) (hcmin : ∀ j : ℤ, j < h → c j = 0)
+    {p₀ : ℕ} (hsum : Summable (boundedSideTail B c h p₀))
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) : False := by
+  have hchpos := norm_pos_iff.mpr hch
+  have ht := boundedSideTail_tendsto hB (hB.slopes_tendsto hB0 hδ hquad) c h hsum
+  obtain ⟨N, hN⟩ := eventually_atTop.1 (ht (eventually_lt_nhds hchpos))
+  obtain ⟨n, hn, hcurv⟩ := large_curvature hδ hδ hquad (max N (max p₀ (h.toNat+1)))
+  let p := n+1
+  have hp₀ : p₀ ≤ p := by dsimp [p]; omega
+  have hpN : N ≤ p := by dsimp [p]; omega
+  have hph : h < (p : ℤ) := by dsimp [p]; omega
+  have hcontact : ‖b (p : ℤ)‖ = Real.exp (-B p) := hc n (by simpa using hcurv)
+  have htailsum : Summable (boundedSideTail B c h p) := by
+    apply hsum.of_norm_bounded
+    intro k
+    rw [Real.norm_eq_abs, abs_of_nonneg (boundedSideTail_nonneg _ _ _ _ _)]
+    exact boundedSideTail_mono hB c h hp₀ k
+  let f := fun i : ℤ => b ((p:ℤ)+i) * c (h+i)
+  have hfneg : ∀ k : ℕ, f (-((k:ℤ)+1)) = 0 := by
+    intro k
+    dsimp [f]
+    rw [hcmin _ (by omega), mul_zero]
+  have hfbound (k : ℕ) : ‖f ((k:ℤ)+1)‖ ≤ Real.exp (-B p) * boundedSideTail B c h p k := by
+    dsimp [f, boundedSideTail]
+    rw [norm_mul, ← mul_assoc, ← Real.exp_add]
+    have he : -B p + (B p - B (p+k+1)) = -B (p+k+1) := by ring
+    rw [he]
+    have hi : (p:ℤ)+((k:ℤ)+1) = ((p+k+1:ℕ):ℤ) := by omega
+    rw [hi]
+    simpa only [add_assoc] using mul_le_mul_of_nonneg_right (hb (p+k+1)) (norm_nonneg (c (h+(k:ℤ)+1)))
+  have hfpos : Summable (fun k : ℕ => ‖f ((k:ℤ)+1)‖) := by
+    apply (htailsum.mul_left (Real.exp (-B p))).of_norm_bounded
+    intro k
+    simpa only [Real.norm_eq_abs, abs_of_nonneg (norm_nonneg _)] using hfbound k
+  have hfn : Summable (fun k : ℕ => ‖f (-((k:ℤ)+1))‖) := by
+    simp only [hfneg, norm_zero]
+    exact summable_zero
+  have hzcenter : (∑' i : ℤ, f i) = 0 := by
+    let r := ((p:ℤ)-h).toNat
+    have hr : 1 ≤ r := by dsimp [r]; omega
+    have hri : (r:ℤ) = (p:ℤ)-h := by dsimp [r]; omega
+    calc (∑' i : ℤ, f i) = ∑' i : ℤ, b ((p:ℤ)+i) * c (((p:ℤ)+i)-(r:ℤ)) := by
+          apply tsum_congr
+          intro i
+          dsimp [f]
+          congr 2
+          omega
+      _ = ∑' j : ℤ, b j * c (j-r) := by
+          simpa only [Equiv.coe_addLeft] using
+            (Equiv.addLeft (p:ℤ)).tsum_eq (fun j : ℤ => b j * c (j-r))
+      _ = 0 := hz r hr
+  have hcentral := central_norm_le_of_correlation_zero f hfpos hfn hzcenter
+  simp only [hfneg, norm_zero, tsum_zero, add_zero] at hcentral
+  have hcentral' : Real.exp (-B p) * ‖c h‖ ≤
+      Real.exp (-B p) * ∑' k, boundedSideTail B c h p k := by
+    calc Real.exp (-B p) * ‖c h‖ = ‖f 0‖ := by simp [f, hcontact]
+      _ ≤ ∑' k : ℕ, ‖f ((k:ℤ)+1)‖ := hcentral
+      _ ≤ ∑' k, Real.exp (-B p) * boundedSideTail B c h p k :=
+        hfpos.tsum_le_tsum hfbound (htailsum.mul_left _)
+      _ = _ := tsum_mul_left
+  have hle := (mul_le_mul_iff_right₀ (Real.exp_pos (-B p))).mp hcentral'
+  exact (not_lt_of_ge hle) (hN p hpN)
+
+
+def positiveLog (w : ℤ → ℝ) (n : ℕ) : ℝ := -Real.log (w n)
+def negativeLog (w : ℤ → ℝ) (n : ℕ) : ℝ := Real.log (w (-(n:ℤ)))
+def stepRatio (w : ℤ → ℝ) (j : ℤ) : ℝ := w (j+1) / w j
+
+lemma stepRatio_summable {w : ℤ → ℝ} (hw : ∀ j, 0 < w j) (hw0 : w 0 = 1)
+    (hP : DiscreteConvex (negativeLog w)) (hQ : DiscreteConvex (positiveLog w))
+    {δ : ℝ} (hδ : 0 < δ)
+    (hqp : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ negativeLog w n)
+    (hqq : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ positiveLog w n) :
+    Summable (stepRatio w) := by
+  have hP0 : negativeLog w 0 = 0 := by simp [negativeLog, hw0]
+  have hQ0 : positiveLog w 0 = 0 := by simp [positiveLog, hw0]
+  have hsP := hP.summable_exp_neg_slope hP0 hδ hqp
+  have hsQ := hQ.summable_exp_neg_slope hQ0 hδ hqq
+  apply Summable.of_nat_of_neg_add_one
+  · apply hsQ.congr
+    intro n
+    unfold stepRatio positiveLog
+    have he : -(-Real.log (w (n+1)) - -Real.log (w n)) =
+        Real.log (w (n+1)) - Real.log (w n) := by ring
+    push_cast
+    rw [he, Real.exp_sub, Real.exp_log (hw _), Real.exp_log (hw _)]
+  · apply hsP.congr
+    intro n
+    unfold stepRatio negativeLog
+    have hi : -((n:ℤ)+1)+1 = -(n:ℤ) := by omega
+    rw [hi]
+    push_cast
+    rw [neg_sub, Real.exp_sub, Real.exp_log (hw _), Real.exp_log (hw _)]
+
+lemma bounds_of_weight {w : ℤ → ℝ} (hw : ∀ j, 0 < w j) {b c : ℤ → ℂ}
+    (hb : ∀ j, ‖b j‖ ≤ w j) (hc : ∀ j, ‖c j‖ * w j ≤ 1) :
+    EnvelopeBounds (negativeLog w) (positiveLog w) b c := by
+  have hc' (j : ℤ) : ‖c j‖ ≤ (w j)⁻¹ := by
+    simpa only [one_div] using (le_div_iff₀ (hw j)).mpr (hc j)
+  constructor
+  · intro n
+    simpa [positiveLog, Real.exp_log (hw _)] using hb n
+  · intro n
+    simpa [negativeLog, Real.exp_log (hw _)] using hb (-(n:ℤ))
+  · intro n
+    simpa [positiveLog, Real.exp_neg, Real.exp_log (hw _)] using hc' n
+  · intro n
+    simpa [negativeLog, Real.exp_neg, Real.exp_log (hw _)] using hc' (-(n:ℤ))
+
+lemma boundedSideTail_summable {w : ℤ → ℝ} (hw : ∀ j, 0 < w j)
+    (hdec : Antitone w) (hs : Summable (stepRatio w))
+    {B : ℕ → ℝ} (hBw : ∀ n : ℕ, Real.exp (-B n) ≤ w n)
+    {c : ℤ → ℂ} (hc : ∀ j, ‖c j‖ * w j ≤ 1)
+    (h : ℤ) {p₀ : ℕ} (hp₀ : h+1 ≤ (p₀:ℤ)) :
+    Summable (boundedSideTail B c h p₀) := by
+  have hsm := hs.comp_injective (i := fun k : ℕ => h+(k:ℤ)+1) (by
+    intro a b hab; dsimp only at hab; omega)
+  apply (hsm.mul_left (Real.exp (B p₀))).of_norm_bounded
+  intro k
+  rw [Real.norm_eq_abs, abs_of_nonneg (boundedSideTail_nonneg _ _ _ _ _)]
+  change boundedSideTail B c h p₀ k ≤ Real.exp (B p₀) * stepRatio w (h+(k:ℤ)+1)
+  have hwle : Real.exp (-B (p₀+k+1)) ≤ w (h+(k:ℤ)+1+1) := by
+    exact (hBw _).trans (hdec (by omega))
+  have hcw : ‖c (h+(k:ℤ)+1)‖ ≤ 1 / w (h+(k:ℤ)+1) :=
+    (le_div_iff₀ (hw _)).mpr (hc _)
+  unfold boundedSideTail stepRatio
+  rw [Real.exp_sub, div_eq_mul_inv, ← Real.exp_neg, mul_assoc]
+  apply mul_le_mul_of_nonneg_left _ (Real.exp_pos _).le
+  calc Real.exp (-B (p₀+k+1)) * ‖c (h+(k:ℤ)+1)‖ ≤
+      w (h+(k:ℤ)+1+1) * (1 / w (h+(k:ℤ)+1)) :=
+        mul_le_mul hwle hcw (norm_nonneg _) (hw _).le
+    _ = _ := by ring
+
+lemma nat_support_unbounded {d : ℤ → ℂ}
+    (hu : ¬∃ m : ℤ, ∀ j : ℤ, d j ≠ 0 → j ≤ m) :
+    ∀ n : ℕ, ∃ k, n < k ∧ d (k:ℤ) ≠ 0 := by
+  push Not at hu
+  intro n
+  obtain ⟨j, hd, hj⟩ := hu n
+  refine ⟨j.toNat, by omega, ?_⟩
+  have he : (j.toNat:ℤ) = j := by omega
+  simpa only [he] using hd
+
+
+
+lemma bounded_above_of_min {w : ℤ → ℝ} (hw : ∀ j, 0 < w j)
+    (hdec : Antitone w) (hw0 : w 0 = 1) (hs : Summable (stepRatio w))
+    (hQ : DiscreteConvex (positiveLog w)) {δ : ℝ} (hδ : 0 < δ)
+    (hqq : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ positiveLog w n)
+    {b c : ℤ → ℂ} (hb : ∀ j, ‖b j‖ ≤ w j) (hc : ∀ j, ‖c j‖*w j ≤ 1)
+    {h : ℤ} (hch : c h ≠ 0) (hcmin : ∀ j : ℤ, j < h → c j = 0)
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) :
+    ∃ m : ℤ, ∀ j : ℤ, b j ≠ 0 → j ≤ m := by
+  by_contra hu
+  have hbu := nat_support_unbounded hu
+  have hQ0 : positiveLog w 0 = 0 := by simp [positiveLog, hw0]
+  obtain ⟨hB0, hB, hQB, hbB, hcontactB⟩ :=
+    CoefficientEnvelope.properties hbu hQ hQ0 (bounds_of_weight hw hb hc).b_pos
+  let B := coefficientEnvelope (fun n => b (n:ℤ))
+  have hquad : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ B n := by
+    filter_upwards [hqq] with n hn using hn.trans (hQB n)
+  have hBw (n : ℕ) : Real.exp (-B n) ≤ w n := by
+    have hh := Real.exp_le_exp.mpr (neg_le_neg (hQB n))
+    simpa only [positiveLog, neg_neg, Real.exp_log (hw _)] using hh
+  exact no_unbounded_against_min hB hB0 hδ hquad hbB hcontactB hch hcmin
+    (boundedSideTail_summable hw hdec hs hBw hc h (p₀ := h.toNat+1) (by omega)) hz
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ConvexEnvelope.lean

@@ -0,0 +1,398 @@
+import Mathlib
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+
+
+def DiscreteConvex (F : ℕ → ℝ) : Prop :=
+  Monotone (fun n => F (n + 1) - F n)
+
+namespace DiscreteConvex
+
+variable {F : ℕ → ℝ}
+
+lemma of_step (h : ∀ n, F (n+1) - F n ≤ F (n+2) - F (n+1)) :
+    DiscreteConvex F := by
+  exact monotone_nat_of_le_succ h
+
+lemma step (h : DiscreteConvex F) (n : ℕ) :
+    F (n+1) - F n ≤ F (n+2) - F (n+1) := by
+  exact h (Nat.le_succ n)
+
+lemma sub_zero_le (h : DiscreteConvex F) (n : ℕ) :
+    F n - F 0 ≤ (n : ℝ) * (F (n+1) - F n) := by
+  induction n with
+  | zero => simp
+  | succ n hn =>
+    have hs := h.step n
+    have hn0 : (0 : ℝ) ≤ n := Nat.cast_nonneg n
+    push_cast
+    nlinarith
+
+lemma secant_le (h : DiscreteConvex F) {n m : ℕ} (hnm : n ≤ m) :
+    (m : ℝ) * (F n - F 0) ≤ (n : ℝ) * (F m - F 0) := by
+  induction m, hnm using Nat.le_induction with
+  | base => rfl
+  | succ m hnm ih =>
+    have hs := h.sub_zero_le n
+    have hd := h hnm
+    have hn0 : (0 : ℝ) ≤ n := Nat.cast_nonneg n
+    have ht : F n - F 0 ≤ (n : ℝ) * (F (m+1) - F m) := by
+      calc F n - F 0 ≤ (n : ℝ) * (F (n+1) - F n) := hs
+           _ ≤ (n : ℝ) * (F (m+1) - F m) := mul_le_mul_of_nonneg_left hd hn0
+    push_cast
+    nlinarith
+
+lemma le_endpoint (h : DiscreteConvex F) (h0 : F 0 = 0)
+    {n m : ℕ} (hnm : n ≤ m) (hm : 0 < m) (B : ℝ) (hB : 0 ≤ B)
+    (hend : F m ≤ B) : F n ≤ B := by
+  have hs := h.secant_le hnm
+  rw [h0, sub_zero, sub_zero] at hs
+  have hn0 : (0 : ℝ) ≤ n := Nat.cast_nonneg n
+  have hm0 : (0 : ℝ) < m := Nat.cast_pos.mpr hm
+  have hnm' : (n : ℝ) ≤ m := Nat.cast_le.mpr hnm
+  have hh : (m : ℝ) * F n ≤ (m : ℝ) * B := calc
+    (m : ℝ) * F n ≤ (n : ℝ) * F m := hs
+    _ ≤ (n : ℝ) * B := mul_le_mul_of_nonneg_left hend hn0
+    _ ≤ (m : ℝ) * B := mul_le_mul_of_nonneg_right hnm' hB
+  exact (mul_le_mul_iff_right₀ hm0).mp hh
+
+
+lemma bump (h : DiscreteConvex F) (n : ℕ) {ε : ℝ} (hε : 0 ≤ ε)
+    (hgap : 2 * ε ≤ F (n+2) - 2 * F (n+1) + F n) :
+    DiscreteConvex (fun k => F k + if k = n+1 then ε else 0) := by
+  apply of_step
+  intro k
+  by_cases hk : k = n
+  · subst k
+    have hne : n ≠ n+1 := by omega
+    have hne' : n+2 ≠ n+1 := by omega
+    simp only [ite_eq_right hne, ite_eq_right hne', ite_true, add_zero]
+    linarith
+  · have hmid : k+1 ≠ n+1 := by omega
+    have hlo : F k ≤ F k + if k = n+1 then ε else 0 := by
+      split_ifs <;> linarith
+    have hhi : F (k+2) ≤ F (k+2) + if k+2 = n+1 then ε else 0 := by
+      split_ifs <;> linarith
+    simp only [ite_eq_right hmid, add_zero]
+    have hs := h.step k
+    linarith
+
+end DiscreteConvex
+
+
+
+
+def convexMinorants (I : Set ℕ) (f : ℕ → ℝ) : Set (ℕ → ℝ) :=
+  {F | F 0 = 0 ∧ DiscreteConvex F ∧ ∀ n ∈ I, F n ≤ f n}
+
+
+def convexEnvelope (I : Set ℕ) (f : ℕ → ℝ) (n : ℕ) : ℝ :=
+  sSup ((fun F : ℕ → ℝ => F n) '' convexMinorants I f)
+
+namespace ConvexEnvelope
+
+variable {I : Set ℕ} {f : ℕ → ℝ}
+variable (hunbounded : ∀ n : ℕ, ∃ k, n < k ∧ k ∈ I)
+variable (hne : (convexMinorants I f).Nonempty)
+
+include hunbounded in
+lemma bddAbove (n : ℕ) :
+    BddAbove ((fun F : ℕ → ℝ => F n) '' convexMinorants I f) := by
+  obtain ⟨k, hnk, hkI⟩ := hunbounded n
+  refine ⟨max 0 (f k), ?_⟩
+  rintro _ ⟨F, hF, rfl⟩
+  exact hF.2.1.le_endpoint hF.1 (Nat.le_of_lt hnk) (by omega)
+    _ (le_max_left _ _) ((hF.2.2 k hkI).trans (le_max_right _ _))
+
+include hunbounded in
+lemma le_envelope {F : ℕ → ℝ} (hF : F ∈ convexMinorants I f) (n : ℕ) :
+    F n ≤ convexEnvelope I f n := by
+  exact le_csSup (bddAbove hunbounded n) ⟨F, hF, rfl⟩
+
+include hunbounded hne in
+lemma zero : convexEnvelope I f 0 = 0 := by
+  apply le_antisymm
+  · apply csSup_le (hne.image _)
+    rintro _ ⟨F, hF, rfl⟩
+    exact le_of_eq hF.1
+  · obtain ⟨F, hF⟩ := hne
+    simpa only [hF.1] using le_envelope hunbounded hF 0
+
+include hunbounded hne in
+lemma convex : DiscreteConvex (convexEnvelope I f) := by
+  apply DiscreteConvex.of_step
+  intro n
+  have hh : convexEnvelope I f (n+1) ≤
+      (convexEnvelope I f n + convexEnvelope I f (n+2)) / 2 := by
+    apply csSup_le (hne.image _)
+    rintro _ ⟨F, hF, rfl⟩
+    have hc := hF.2.1.step n
+    have hl := le_envelope hunbounded hF n
+    have hr := le_envelope hunbounded hF (n+2)
+    linarith
+  linarith
+
+include hne in
+lemma below {n : ℕ} (hn : n ∈ I) : convexEnvelope I f n ≤ f n := by
+  apply csSup_le (hne.image _)
+  rintro _ ⟨F, hF, rfl⟩
+  exact hF.2.2 n hn
+
+include hunbounded hne in
+lemma mem : convexEnvelope I f ∈ convexMinorants I f :=
+  ⟨zero hunbounded hne, convex hunbounded hne, fun _ hn => below hne hn⟩
+
+include hunbounded hne in
+
+lemma contact (n : ℕ)
+    (hgap : 0 < convexEnvelope I f (n+2) - 2 * convexEnvelope I f (n+1) +
+      convexEnvelope I f n) :
+    n+1 ∈ I ∧ convexEnvelope I f (n+1) = f (n+1) := by
+  let F := convexEnvelope I f
+  let δ := F (n+2) - 2 * F (n+1) + F n
+  have hδ : 0 < δ := hgap
+  have hF : F ∈ convexMinorants I f := mem hunbounded hne
+  have maximal : ∀ ε : ℝ, 0 < ε → 2*ε ≤ δ →
+      (n+1 ∈ I → F (n+1)+ε ≤ f (n+1)) → False := by
+    intro ε hε hεgap hεobs
+    let G := fun k => F k + if k = n+1 then ε else 0
+    have hG : G ∈ convexMinorants I f := by
+      refine ⟨?_, hF.2.1.bump n hε.le hεgap, ?_⟩
+      · simp [G, hF.1]
+      · intro k hk
+        by_cases he : k = n+1
+        · subst k
+          simpa [G] using hεobs hk
+        · simpa [G, he] using hF.2.2 k hk
+    have hle := le_envelope hunbounded hG (n+1)
+    simp only [G, ite_true] at hle
+    change F (n+1) + ε ≤ F (n+1) at hle
+    linarith
+  have hi : n+1 ∈ I := by
+    by_contra hn
+    exact maximal (δ/4) (by positivity) (by linarith) (by simp [hn])
+  refine ⟨hi, ?_⟩
+  have hle := hF.2.2 (n+1) hi
+  by_contra hneq
+  have hlt : F (n+1) < f (n+1) := lt_of_le_of_ne hle hneq
+  let ε := min (δ/4) ((f (n+1) - F (n+1))/2)
+  have hε : 0 < ε := lt_min (by positivity) (by linarith)
+  have hε₁ : ε ≤ δ/4 := min_le_left _ _
+  have hε₂ : ε ≤ (f (n+1) - F (n+1))/2 := min_le_right _ _
+  exact maximal ε hε (by linarith) (by intro _; linarith)
+
+end ConvexEnvelope
+
+namespace DiscreteConvex
+
+variable {F : ℕ → ℝ}
+
+
+lemma slopes_tendsto (h : DiscreteConvex F) (h0 : F 0 = 0)
+    {δ : ℝ} (hδ : 0 < δ)
+    (hq : ∀ᶠ n : ℕ in atTop, δ * (n : ℝ)^2 ≤ F n) :
+    Tendsto (fun n => F (n+1) - F n) atTop atTop := by
+  apply tendsto_atTop.2
+  intro b
+  have hn : ∀ᶠ n : ℕ in atTop, b / δ ≤ (n : ℝ) :=
+    (tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop)
+      (eventually_ge_atTop _)
+  filter_upwards [hq, hn, eventually_ge_atTop 1] with n hqn hbn hn1
+  have hnpos : (0 : ℝ) < n := Nat.cast_pos.mpr (by omega)
+  have hs := h.sub_zero_le n
+  rw [h0, sub_zero] at hs
+  have hb : b ≤ δ * n := (div_le_iff₀ hδ).mp hbn |>.trans_eq (mul_comm _ _)
+  have hd : δ * n ≤ F (n+1) - F n := by nlinarith
+  exact hb.trans hd
+
+end DiscreteConvex
+
+
+
+lemma quadratic_upper_of_curvature {F : ℕ → ℝ} {lam : ℝ} (N : ℕ)
+    (h : ∀ n, N ≤ n → F (n+2) - 2*F (n+1) + F n ≤ 2*lam) (k : ℕ) :
+    F (N+k) ≤ F N + (k : ℝ) * (F (N+1) - F N) + lam * k * (k-1) := by
+  have hs (k : ℕ) : F (N+k+1) - F (N+k) ≤
+      F (N+1) - F N + 2*lam*k := by
+    induction k with
+    | zero => simp
+    | succ k ih =>
+      have hh := h (N+k) (Nat.le_add_right _ _)
+      have e₁ : N + (k+1) + 1 = N+k+2 := by omega
+      have e₂ : N + (k+1) = N+k+1 := by omega
+      rw [e₁, e₂]
+      push_cast
+      linarith
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    have hh := hs k
+    have e : N + (k+1) = N+k+1 := by omega
+    rw [e]
+    push_cast
+    nlinarith
+
+
+
+
+lemma large_curvature {F : ℕ → ℝ} {lam μ : ℝ} (hμ : 0 < μ) (hlamμ : lam < μ)
+    (hq : ∀ᶠ n : ℕ in atTop, μ * (n : ℝ)^2 ≤ F n) :
+    ∀ N : ℕ, ∃ n, N ≤ n ∧ 2*lam < F (n+2) - 2*F (n+1) + F n := by
+  intro N
+  by_contra! h
+  obtain ⟨Q, hQ⟩ := eventually_atTop.1 hq
+  let C := |F (N+1) - F N - lam| + |F N|
+  obtain ⟨k, hk⟩ := exists_nat_gt (max (max (Q : ℝ) 1) (C / (μ-lam)))
+  have hkQ : (Q : ℝ) < k := lt_of_le_of_lt (le_trans (le_max_left _ _) (le_max_left _ _)) hk
+  have hk1 : (1 : ℝ) < k := lt_of_le_of_lt (le_trans (le_max_right _ _) (le_max_left _ _)) hk
+  have hkC : C / (μ-lam) < k := lt_of_le_of_lt (le_max_right _ _) hk
+  have hk0 : (0 : ℝ) < k := lt_trans zero_lt_one hk1
+  have hQN : Q ≤ N+k := by exact Nat.le_trans (Nat.le_of_lt (Nat.cast_lt.mp hkQ)) (Nat.le_add_left _ _)
+  have hlo := hQ (N+k) hQN
+  have hhi := quadratic_upper_of_curvature N h k
+  have hNC : (0 : ℝ) ≤ N := Nat.cast_nonneg _
+  have hlow : μ * (k : ℝ)^2 ≤ F (N+k) := by
+    push_cast at hlo
+    calc μ * (k : ℝ)^2 ≤ μ * ((N : ℝ) + k)^2 := by gcongr; linarith
+         _ ≤ F (N+k) := hlo
+  have hF0 : F N ≤ |F N| * k := calc
+    F N ≤ |F N| := le_abs_self _
+    _ ≤ |F N| * k := le_mul_of_one_le_right (abs_nonneg _) hk1.le
+  have hF1 : (F (N+1) - F N - lam) * k ≤ |F (N+1) - F N - lam| * k :=
+    mul_le_mul_of_nonneg_right (le_abs_self _) hk0.le
+  have hup : F (N+k) ≤ lam * (k : ℝ)^2 + C*k := by
+    dsimp [C]
+    nlinarith [hhi]
+  have hlarge : C < (k : ℝ) * (μ-lam) := (div_lt_iff₀ (sub_pos.mpr hlamμ)).mp hkC
+  have hstrict := mul_lt_mul_of_pos_right hlarge hk0
+  nlinarith
+
+namespace DiscreteConvex
+
+variable {F : ℕ → ℝ}
+
+lemma increment_mono (h : DiscreteConvex F) {i j : ℕ} (hij : i ≤ j) (k : ℕ) :
+    F (i+k) - F i ≤ F (j+k) - F j := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    have hh := h (Nat.add_le_add_right hij k)
+    have e₁ : i + (k+1) = i+k+1 := by omega
+    have e₂ : j + (k+1) = j+k+1 := by omega
+    rw [e₁, e₂]
+    linarith
+
+lemma increment_lower (h : DiscreteConvex F) (q k : ℕ) :
+    (k : ℝ) * (F (q+1) - F q) ≤ F (q+k) - F q := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    have hh := h (Nat.le_add_right q k)
+    have e : q + (k+1) = q+k+1 := by omega
+    rw [e]
+    push_cast
+    nlinarith
+
+lemma increment_upper (h : DiscreteConvex F) (q k r : ℕ) (hkr : q+k ≤ r+1) :
+    F (q+k) - F q ≤ (k : ℝ) * (F (r+1) - F r) := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    have hh := h (show q+k ≤ r by omega)
+    have ih' := ih (by omega)
+    have e : q + (k+1) = q+k+1 := by omega
+    rw [e]
+    push_cast
+    nlinarith
+
+lemma summable_exp_neg_slope (h : DiscreteConvex F) (h0 : F 0 = 0)
+    {δ : ℝ} (hδ : 0 < δ)
+    (hq : ∀ᶠ n : ℕ in atTop, δ * (n : ℝ)^2 ≤ F n) :
+    Summable (fun n => Real.exp (-(F (n+1) - F n))) := by
+  have hgeo : Summable (fun n : ℕ => Real.exp (-δ) ^ n) :=
+    summable_geometric_of_lt_one (Real.exp_pos _).le (by simpa using hδ)
+  apply hgeo.of_norm_bounded_eventually_nat
+  filter_upwards [hq, eventually_ge_atTop 1] with n hqn hn1
+  have hnpos : (0 : ℝ) < n := Nat.cast_pos.mpr (by omega)
+  have hs := h.sub_zero_le n
+  rw [h0, sub_zero] at hs
+  have hd : δ * n ≤ F (n+1) - F n := by nlinarith
+  rw [Real.norm_eq_abs, abs_of_pos (Real.exp_pos _), ← Real.exp_nat_mul]
+  exact Real.exp_le_exp.mpr (by nlinarith)
+
+end DiscreteConvex
+
+
+def normalizedTailTerm (F : ℕ → ℝ) (q k : ℕ) : ℝ :=
+  Real.exp (F (k+1) + F q - F (q+k+1))
+
+namespace DiscreteConvex
+
+variable {F : ℕ → ℝ}
+
+lemma tail_term_bound (h : DiscreteConvex F) {q : ℕ} (hq : 1 ≤ q) (k : ℕ) :
+    normalizedTailTerm F q k ≤
+      Real.exp (F 1) * Real.exp (-(F (k+2) - F (k+1))) := by
+  have hi := h.increment_mono hq (k+1)
+  have e₁ : 1+(k+1) = k+2 := by omega
+  have e₂ : q+(k+1) = q+k+1 := by omega
+  rw [e₁, e₂] at hi
+  rw [normalizedTailTerm, ← Real.exp_add]
+  exact Real.exp_le_exp.mpr (by linarith)
+
+lemma tail_term_tendsto (h : DiscreteConvex F)
+    (hs : Tendsto (fun n => F (n+1) - F n) atTop atTop) (k : ℕ) :
+    Tendsto (fun q => normalizedTailTerm F q k) atTop (𝓝 0) := by
+  apply Real.tendsto_exp_atBot.comp
+  apply tendsto_atBot.2
+  intro b
+  have hsl := hs (eventually_ge_atTop (max 0 (F (k+1) - b)))
+  filter_upwards [hsl] with q hq
+  have hs0 : 0 ≤ F (q+1) - F q := (le_max_left _ _).trans hq
+  have hsb : F (k+1) - b ≤ F (q+1) - F q := (le_max_right _ _).trans hq
+  have hi := h.increment_lower q (k+1)
+  have e : q+(k+1) = q+k+1 := by omega
+  rw [e] at hi
+  have hk0 : (0 : ℝ) ≤ k := Nat.cast_nonneg k
+  push_cast at hi
+  change F (k+1) + F q - F (q+k+1) ≤ b
+  nlinarith
+
+lemma tail_summable (h : DiscreteConvex F)
+    (hsum : Summable (fun n => Real.exp (-(F (n+1) - F n))))
+    {q : ℕ} (hq : 1 ≤ q) : Summable (normalizedTailTerm F q) := by
+  have hmajor := ((summable_nat_add_iff 1).mpr hsum).mul_left (Real.exp (F 1))
+  apply hmajor.of_norm_bounded
+  intro k
+  rw [Real.norm_eq_abs, abs_of_pos (show 0 < normalizedTailTerm F q k from Real.exp_pos _)]
+  simpa only [Nat.add_assoc] using h.tail_term_bound hq k
+
+
+
+lemma tail_tsum_tendsto (h : DiscreteConvex F)
+    (hsum : Summable (fun n => Real.exp (-(F (n+1) - F n))))
+    (hs : Tendsto (fun n => F (n+1) - F n) atTop atTop) :
+    Tendsto (fun q => ∑' k, normalizedTailTerm F q k) atTop (𝓝 0) := by
+  have hmajor := ((summable_nat_add_iff 1).mpr hsum).mul_left (Real.exp (F 1))
+  have hh := tendsto_tsum_of_dominated_convergence hmajor
+    (fun k => h.tail_term_tendsto hs k) (show ∀ᶠ q : ℕ in atTop, ∀ k,
+      ‖normalizedTailTerm F q k‖ ≤
+        Real.exp (F 1) * Real.exp (-(F (k+1+1) - F (k+1))) from ?_)
+  · simpa using hh
+  · filter_upwards [eventually_ge_atTop 1] with q hq k
+    rw [Real.norm_eq_abs, abs_of_pos (show 0 < normalizedTailTerm F q k from Real.exp_pos _)]
+    simpa only [Nat.add_assoc] using h.tail_term_bound hq k
+
+end DiscreteConvex
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ConvolutionBounds.lean

@@ -0,0 +1,320 @@
+import OAI.Analysis.BackwardIntertwiners.ConvexEnvelope
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+
+structure EnvelopeBounds (A B : ℕ → ℝ) (b c : ℤ → ℂ) : Prop where
+  b_pos : ∀ n : ℕ, ‖b n‖ ≤ Real.exp (-B n)
+  b_neg : ∀ n : ℕ, ‖b (-(n : ℤ))‖ ≤ Real.exp (A n)
+  c_pos : ∀ n : ℕ, ‖c n‖ ≤ Real.exp (B n)
+  c_neg : ∀ n : ℕ, ‖c (-(n : ℤ))‖ ≤ Real.exp (-A n)
+
+lemma middle_exponent {A B : ℕ → ℝ} (hA : DiscreteConvex A) (hB : DiscreteConvex B)
+    {m : ℕ} (hm : 1 ≤ m) (p k : ℕ) (hk : k ≤ m) {lam : ℝ}
+    (hbridge : A m - A (m-1) + lam ≤ B (p+1) - B p) :
+    -B (p+k) - A (m-k) ≤ -B p - A m - lam * k := by
+  have hlow := hB.increment_lower p k
+  have hupp := hA.increment_upper (m-k) k (m-1) (by omega)
+  rw [Nat.sub_add_cancel hk, Nat.sub_add_cancel hm] at hupp
+  have hmul := mul_le_mul_of_nonneg_left hbridge (Nat.cast_nonneg k : (0 : ℝ) ≤ k)
+  nlinarith
+
+
+def centeredCorrelation (b c : ℤ → ℂ) (m p : ℕ) (n : ℤ) : ℂ :=
+  b ((p : ℤ)+n) * c (-(m : ℤ)+n)
+
+namespace EnvelopeBounds
+
+variable {A B : ℕ → ℝ} {b c : ℤ → ℂ}
+
+lemma reflected (hb : EnvelopeBounds A B b c) :
+    EnvelopeBounds B A (fun n => c (-n)) (fun n => b (-n)) where
+  b_pos := hb.c_neg
+  b_neg := by simpa only [neg_neg] using hb.c_pos
+  c_pos := hb.b_neg
+  c_neg := by simpa only [neg_neg] using hb.b_pos
+
+lemma central_norm (_ : EnvelopeBounds A B b c) {m p : ℕ}
+    (hp : ‖b (p : ℤ)‖ = Real.exp (-B p))
+    (hm : ‖c (-(m : ℤ))‖ = Real.exp (-A m)) :
+    ‖centeredCorrelation b c m p 0‖ = Real.exp (-B p - A m) := by
+  simp only [centeredCorrelation, add_zero, norm_mul, hp, hm]
+  rw [← Real.exp_add]
+  congr 1
+
+lemma middle_pos (hb : EnvelopeBounds A B b c)
+    (hA : DiscreteConvex A) (hB : DiscreteConvex B)
+    {m : ℕ} (hm : 1 ≤ m) (p k : ℕ) (hk : k ≤ m) {lam : ℝ}
+    (hbridge : A m - A (m-1) + lam ≤ B (p+1) - B p) :
+    ‖centeredCorrelation b c m p k‖ ≤
+      Real.exp (-B p - A m) * Real.exp (-lam * k) := by
+  have he : -(m : ℤ) + k = -((m-k : ℕ) : ℤ) := by omega
+  rw [centeredCorrelation, he, ← Nat.cast_add, norm_mul]
+  calc ‖b ((p+k : ℕ) : ℤ)‖ * ‖c (-((m-k : ℕ) : ℤ))‖ ≤
+      Real.exp (-B (p+k)) * Real.exp (-A (m-k)) :=
+      mul_le_mul (hb.b_pos _) (hb.c_neg _) (norm_nonneg _) (Real.exp_pos _).le
+    _ ≤ Real.exp (-B p - A m) * Real.exp (-lam * k) := by
+      rw [← Real.exp_add, ← Real.exp_add]
+      apply Real.exp_le_exp.mpr
+      simpa only [sub_eq_add_neg, neg_mul] using middle_exponent hA hB hm p k hk hbridge
+
+lemma middle_neg (hb : EnvelopeBounds A B b c)
+    (hA : DiscreteConvex A) (hB : DiscreteConvex B)
+    {p : ℕ} (hp : 1 ≤ p) (m k : ℕ) (hk : k ≤ p) {lam : ℝ}
+    (hbridge : B p - B (p-1) + lam ≤ A (m+1) - A m) :
+    ‖centeredCorrelation b c m p (-(k : ℤ))‖ ≤
+      Real.exp (-B p - A m) * Real.exp (-lam * k) := by
+  have hh := hb.reflected.middle_pos hB hA hp m k hk hbridge
+  simpa only [centeredCorrelation, neg_add, neg_neg, mul_comm, neg_add_rev,
+    sub_eq_add_neg, add_comm] using hh
+
+lemma tail_pos (hb : EnvelopeBounds A B b c) (m p k : ℕ)
+    (hend : B p + A m ≤ B (m+p)) :
+    ‖centeredCorrelation b c m p ((m+k+1 : ℕ) : ℤ)‖ ≤
+      Real.exp (-B p - A m) * normalizedTailTerm B (m+p) k := by
+  have e₁ : (p : ℤ) + ((m+k+1 : ℕ) : ℤ) = ((m+p+k+1 : ℕ) : ℤ) := by omega
+  have e₂ : -(m : ℤ) + ((m+k+1 : ℕ) : ℤ) = ((k+1 : ℕ) : ℤ) := by omega
+  rw [centeredCorrelation, e₁, e₂, norm_mul]
+  calc ‖b ((m+p+k+1 : ℕ) : ℤ)‖ * ‖c ((k+1 : ℕ) : ℤ)‖ ≤
+      Real.exp (-B (m+p+k+1)) * Real.exp (B (k+1)) :=
+      mul_le_mul (hb.b_pos _) (hb.c_pos _) (norm_nonneg _) (Real.exp_pos _).le
+    _ ≤ _ := by
+      rw [normalizedTailTerm, ← Real.exp_add, ← Real.exp_add]
+      exact Real.exp_le_exp.mpr (by linarith)
+
+lemma tail_neg (hb : EnvelopeBounds A B b c) (m p k : ℕ)
+    (hend : B p + A m ≤ A (m+p)) :
+    ‖centeredCorrelation b c m p (-((p+k+1 : ℕ) : ℤ))‖ ≤
+      Real.exp (-B p - A m) * normalizedTailTerm A (m+p) k := by
+  have hh := hb.reflected.tail_pos p m k (by simpa [add_comm] using hend)
+  simpa only [centeredCorrelation, neg_add, neg_neg, mul_comm, neg_add_rev,
+    sub_eq_add_neg, add_comm, Nat.add_comm] using hh
+
+end EnvelopeBounds
+
+
+
+lemma tsum_bound_middle_tail {g t u : ℕ → ℝ} {M : ℝ} (hM : 0 ≤ M) (m : ℕ)
+    (hg : ∀ k, 0 ≤ g k) (ht : ∀ k, 0 ≤ t k)
+    (hst : Summable t) (hsu : Summable u)
+    (hmiddle : ∀ k, k < m → g k ≤ M * t k)
+    (htail : ∀ k, g (k+m) ≤ M * u k) :
+    Summable g ∧ (∑' k, g k) ≤ M * (∑' k, t k) + M * (∑' k, u k) := by
+  have htailSum : Summable (fun k => g (k+m)) := by
+    apply (hsu.mul_left M).of_norm_bounded
+    intro k
+    rw [Real.norm_eq_abs, abs_of_nonneg (hg _)]
+    exact htail k
+  have hsum : Summable g := (summable_nat_add_iff m).mp htailSum
+  refine ⟨hsum, ?_⟩
+  rw [← hsum.sum_add_tsum_nat_add m]
+  apply add_le_add
+  · calc ∑ k ∈ Finset.range m, g k ≤ ∑ k ∈ Finset.range m, M * t k :=
+      Finset.sum_le_sum (fun k hk => hmiddle k (Finset.mem_range.mp hk))
+      _ ≤ ∑' k, M * t k := (hst.mul_left M).sum_le_tsum _ (fun k _ => mul_nonneg hM (ht k))
+      _ = M * ∑' k, t k := tsum_mul_left
+  · calc ∑' k, g (k+m) ≤ ∑' k, M * u k := htailSum.tsum_le_tsum htail (hsu.mul_left M)
+      _ = M * ∑' k, u k := tsum_mul_left
+
+lemma central_norm_le_of_correlation_zero (f : ℤ → ℂ)
+    (hp : Summable (fun n : ℕ => ‖f (n+1)‖))
+    (hn : Summable (fun n : ℕ => ‖f (-(n+1))‖))
+    (hz : (∑' n : ℤ, f n) = 0) :
+    ‖f 0‖ ≤ (∑' n : ℕ, ‖f (n+1)‖) + ∑' n : ℕ, ‖f (-(n+1))‖ := by
+  rw [tsum_of_add_one_of_neg_add_one hp.of_norm hn.of_norm] at hz
+  have he : f 0 = -((∑' n : ℕ, f (n+1)) + ∑' n : ℕ, f (-(n+1))) := by
+    linear_combination hz
+  rw [he, norm_neg]
+  exact (norm_add_le _ _).trans (add_le_add (norm_tsum_le_tsum_norm hp) (norm_tsum_le_tsum_norm hn))
+
+
+def geometricMiddle (lam : ℝ) (k : ℕ) : ℝ := Real.exp (-lam * ((k : ℝ)+1))
+
+lemma geometricMiddle_hasSum {lam : ℝ} (hlam : 0 < lam) :
+    HasSum (geometricMiddle lam) (Real.exp (-lam) / (1-Real.exp (-lam))) := by
+  have hr : Real.exp (-lam) < 1 := by simpa using hlam
+  have hh := (hasSum_geometric_of_lt_one (Real.exp_pos (-lam)).le hr).mul_left (Real.exp (-lam))
+  have heq : geometricMiddle lam = (fun k : ℕ => Real.exp (-lam) * Real.exp (-lam)^k) := by
+    funext k
+    rw [geometricMiddle, ← Real.exp_nat_mul, ← Real.exp_add]
+    congr 1
+    ring
+  rw [heq, div_eq_mul_inv]
+  exact hh
+
+lemma geometricMiddle_budget {lam : ℝ} (hlam : Real.log 3 < lam) :
+    2 * (∑' k, geometricMiddle lam k) < 1 := by
+  have hl0 : 0 < lam := (Real.log_pos (by norm_num : (1 : ℝ) < 3)).trans hlam
+  rw [(geometricMiddle_hasSum hl0).tsum_eq]
+  have he : (3 : ℝ) < Real.exp lam := by
+    have h := Real.exp_lt_exp.mpr hlam
+    rw [Real.exp_log (by norm_num : (0 : ℝ) < 3)] at h
+    exact h
+  have hrpos : 0 < Real.exp (-lam) := Real.exp_pos _
+  have hrlt : Real.exp (-lam) < 1 := by simpa using hl0
+  have hprod : Real.exp lam * Real.exp (-lam) = 1 := by
+    rw [← Real.exp_add]; simp
+  have hsmall := mul_lt_mul_of_pos_right he hrpos
+  rw [hprod] at hsmall
+  have hden : 0 < 1 - Real.exp (-lam) := sub_pos.mpr hrlt
+  calc 2 * (Real.exp (-lam) / (1-Real.exp (-lam))) =
+      (2 * Real.exp (-lam)) / (1-Real.exp (-lam)) := by ring
+    _ < 1 := (div_lt_one hden).mpr (by linarith)
+
+namespace EnvelopeBounds
+
+variable {A B : ℕ → ℝ} {b c : ℤ → ℂ}
+
+
+
+lemma correlation_budget (hb : EnvelopeBounds A B b c)
+    (hA : DiscreteConvex A) (hB : DiscreteConvex B)
+    (hA0 : A 0 = 0) (hB0 : B 0 = 0)
+    (hsA : Summable (fun n => Real.exp (-(A (n+1) - A n))))
+    (hsB : Summable (fun n => Real.exp (-(B (n+1) - B n))))
+    {m p : ℕ} (hm : 1 ≤ m) (hp : 1 ≤ p) {lam : ℝ} (hlam : 0 < lam)
+    (hbridge₁ : A m - A (m-1) + lam ≤ B (p+1) - B p)
+    (hbridge₂ : B p - B (p-1) + lam ≤ A (m+1) - A m)
+    (hcB : ‖b (p : ℤ)‖ = Real.exp (-B p))
+    (hcA : ‖c (-(m : ℤ))‖ = Real.exp (-A m))
+    (hz : (∑' n : ℤ, centeredCorrelation b c m p n) = 0) :
+    1 ≤ 2 * (∑' k, geometricMiddle lam k) +
+      (∑' k, normalizedTailTerm A (m+p) k) +
+      (∑' k, normalizedTailTerm B (m+p) k) := by
+  let M := Real.exp (-B p - A m)
+  have hM : 0 < M := Real.exp_pos _
+  have hq : 1 ≤ m+p := by omega
+  have hendB : B p + A m ≤ B (m+p) := by
+    have hh := middle_exponent hA hB hm p m le_rfl hbridge₁
+    simp only [Nat.sub_self, hA0, sub_zero] at hh
+    rw [Nat.add_comm p m] at hh
+    have hmul := mul_nonneg hlam.le (Nat.cast_nonneg m : (0 : ℝ) ≤ m)
+    linarith
+  have hendA : B p + A m ≤ A (m+p) := by
+    have hh := middle_exponent hB hA hp m p le_rfl hbridge₂
+    simp only [Nat.sub_self, hB0, sub_zero] at hh
+    have hmul := mul_nonneg hlam.le (Nat.cast_nonneg p : (0 : ℝ) ≤ p)
+    linarith
+  have hpos := tsum_bound_middle_tail hM.le m
+    (g := fun k : ℕ => ‖centeredCorrelation b c m p ((k : ℤ)+1)‖)
+    (t := geometricMiddle lam) (u := normalizedTailTerm B (m+p))
+    (fun _ => norm_nonneg _) (fun _ => (Real.exp_pos _).le)
+    (geometricMiddle_hasSum hlam).summable (hB.tail_summable hsB hq) ?_ ?_
+  · have hneg := tsum_bound_middle_tail hM.le p
+      (g := fun k : ℕ => ‖centeredCorrelation b c m p (-((k : ℤ)+1))‖)
+      (t := geometricMiddle lam) (u := normalizedTailTerm A (m+p))
+      (fun _ => norm_nonneg _) (fun _ => (Real.exp_pos _).le)
+      (geometricMiddle_hasSum hlam).summable (hA.tail_summable hsA hq) ?_ ?_
+    · have hh := central_norm_le_of_correlation_zero _ hpos.1 hneg.1 hz
+      rw [hb.central_norm hcB hcA] at hh
+      change M ≤ _ at hh
+      have hmul : M * 1 ≤ M * (2 * (∑' k, geometricMiddle lam k) +
+          (∑' k, normalizedTailTerm A (m+p) k) +
+          (∑' k, normalizedTailTerm B (m+p) k)) := by
+        nlinarith [hpos.2, hneg.2]
+      exact (mul_le_mul_iff_right₀ hM).mp hmul
+    · intro k hk
+      simpa [geometricMiddle, M] using
+        hb.middle_neg hA hB hp m (k+1) (by omega) hbridge₂
+    · intro k
+      simpa only [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm, M]
+        using hb.tail_neg m p k hendA
+  · intro k hk
+    simpa [geometricMiddle, M] using
+      hb.middle_pos hA hB hm p (k+1) (by omega) hbridge₁
+  · intro k
+    simpa only [Nat.cast_add, Nat.cast_one, add_assoc, add_comm, add_left_comm, M]
+      using hb.tail_pos m p k hendB
+
+end EnvelopeBounds
+
+
+
+theorem no_correlation_of_envelopes {A B : ℕ → ℝ} {b c : ℤ → ℂ}
+    (hb : EnvelopeBounds A B b c)
+    (hA : DiscreteConvex A) (hB : DiscreteConvex B)
+    (hA0 : A 0 = 0) (hB0 : B 0 = 0)
+    {lam δ : ℝ} (hlam : Real.log 3 < lam) (hδ : lam < δ)
+    (hqa : ∀ᶠ n : ℕ in atTop, δ * (n : ℝ)^2 ≤ A n)
+    (hqb : ∀ᶠ n : ℕ in atTop, δ * (n : ℝ)^2 ≤ B n)
+    (hcA : ∀ n, 0 < A (n+2) - 2*A (n+1) + A n →
+      ‖c (-((n+1 : ℕ) : ℤ))‖ = Real.exp (-A (n+1)))
+    (hcB : ∀ n, 0 < B (n+2) - 2*B (n+1) + B n →
+      ‖b ((n+1 : ℕ) : ℤ)‖ = Real.exp (-B (n+1)))
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) : False := by
+  have hl0 : 0 < lam := (Real.log_pos (by norm_num : (1 : ℝ) < 3)).trans hlam
+  have hδ0 : 0 < δ := hl0.trans hδ
+  have hsA := hA.summable_exp_neg_slope hA0 hδ0 hqa
+  have hsB := hB.summable_exp_neg_slope hB0 hδ0 hqb
+  have htA := hA.slopes_tendsto hA0 hδ0 hqa
+  have htB := hB.slopes_tendsto hB0 hδ0 hqb
+  have ht : Tendsto (fun q => 2 * (∑' k, geometricMiddle lam k) +
+      (∑' k, normalizedTailTerm A q k) + (∑' k, normalizedTailTerm B q k))
+      atTop (𝓝 (2 * ∑' k, geometricMiddle lam k)) := by
+    simpa using (tendsto_const_nhds.add (hA.tail_tsum_tendsto hsA htA)).add
+      (hB.tail_tsum_tendsto hsB htB)
+  obtain ⟨N, hN⟩ := eventually_atTop.1 (ht (eventually_lt_nhds (geometricMiddle_budget hlam)))
+  obtain ⟨K, hK⟩ := eventually_atTop.1 (htA (eventually_ge_atTop (B 1 - B 0 - lam)))
+  obtain ⟨n, hn, hcurv⟩ := large_curvature hδ0 hδ hqa (max N K)
+  let m := n+1
+  have hm : 1 ≤ m := by dsimp [m]; omega
+  have hthreshold : B 1 - B 0 ≤ A m - A (m-1) + lam := by
+    have hh := hK n (le_trans (le_max_right _ _) hn)
+    change B 1 - B 0 - lam ≤ A (n+1) - A n at hh
+    dsimp [m]
+    simpa only [Nat.add_sub_cancel] using (show B 1 - B 0 ≤ A (n+1) - A n + lam by linarith)
+  let C := A m - A (m-1) + lam
+  have hex : ∃ p : ℕ, C < B (p+1) - B p := by
+    have he : ∀ᶠ p : ℕ in atTop, C < B (p+1) - B p := htB (eventually_gt_atTop C)
+    exact he.exists
+  let p := Nat.find hex
+  have hright : C < B (p+1) - B p := Nat.find_spec hex
+  have hp : 1 ≤ p := by
+    by_contra! hh
+    have hp0 : p = 0 := by omega
+    rw [hp0] at hright
+    simp only [zero_add] at hright
+    exact (not_lt_of_ge hthreshold) hright
+  have hleft : B p - B (p-1) ≤ C := by
+    have hh := Nat.find_min hex (show p-1 < p by omega)
+    simpa only [Nat.sub_add_cancel hp, not_lt] using hh
+  have hcontact : 0 < B ((p-1)+2) - 2*B ((p-1)+1) + B (p-1) := by
+    have e₁ : p-1+1 = p := by omega
+    have e₂ : p-1+2 = p+1 := by omega
+    rw [e₁, e₂]
+    linarith
+  have hcB' : ‖b (p : ℤ)‖ = Real.exp (-B p) := by
+    simpa only [Nat.sub_add_cancel hp] using hcB (p-1) hcontact
+  have hcA' : ‖c (-(m : ℤ))‖ = Real.exp (-A m) := hcA n (by linarith)
+  have hbridge₂ : B p - B (p-1) + lam ≤ A (m+1) - A m := by
+    dsimp [C, m] at hleft ⊢
+    have e : n+1+1 = n+2 := by omega
+    rw [e]
+    linarith
+  have hzcenter : (∑' i : ℤ, centeredCorrelation b c m p i) = 0 := by
+    calc (∑' i : ℤ, centeredCorrelation b c m p i) =
+        ∑' i : ℤ, b ((p : ℤ)+i) * c (((p : ℤ)+i) - ((m+p : ℕ) : ℤ)) := by
+          apply tsum_congr
+          intro i
+          unfold centeredCorrelation
+          congr 2
+          omega
+      _ = ∑' j : ℤ, b j * c (j-((m+p : ℕ) : ℤ)) := by
+        simpa only [Equiv.coe_addLeft, add_comm] using
+          (Equiv.addLeft (p : ℤ)).tsum_eq (fun j : ℤ => b j * c (j-((m+p : ℕ) : ℤ)))
+      _ = 0 := hz (m+p) (by omega)
+  have hbudget := hb.correlation_budget hA hB hA0 hB0 hsA hsB hm hp hl0 hright.le
+    hbridge₂ hcB' hcA' hzcenter
+  have hqN : N ≤ m+p := by dsimp [m]; have := le_trans (le_max_left N K) hn; omega
+  exact (not_lt_of_ge hbudget) (hN (m+p) hqN)
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/DiagonalSymbols.lean

@@ -0,0 +1,176 @@
+import OAI.Analysis.BackwardIntertwiners.OrdinaryStructure
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+
+open scoped Classical
+
+def diagonalSymbols : StarSubalgebra ℂ (Base → ℤ → ℂ) where
+  carrier := {a | (∀ j, Measurable (fun x => a x j)) ∧
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ x j, ‖a x j‖ ≤ C}
+  zero_mem' := ⟨fun _ => measurable_const, 0, le_rfl, by simp⟩
+  one_mem' := ⟨fun _ => measurable_const, 1, zero_le_one, by simp⟩
+  add_mem' := by
+    rintro a b ⟨ha,C,hC,hCa⟩ ⟨hb,D,hD,hDb⟩
+    exact ⟨fun j => (ha j).add (hb j), C+D, add_nonneg hC hD,
+      fun x j => (norm_add_le _ _).trans (add_le_add (hCa x j) (hDb x j))⟩
+  mul_mem' := by
+    rintro a b ⟨ha,C,hC,hCa⟩ ⟨hb,D,hD,hDb⟩
+    refine ⟨fun j => (ha j).mul (hb j), C*D, mul_nonneg hC hD, fun x j => ?_⟩
+    change ‖a x j * b x j‖ ≤ C*D
+    rw [norm_mul]
+    exact mul_le_mul (hCa x j) (hDb x j) (norm_nonneg _) hC
+  algebraMap_mem' c := ⟨fun _ => measurable_const, ‖c‖, norm_nonneg c, fun _ _ => le_rfl⟩
+  star_mem' := by
+    rintro a ⟨ha,C,hC,hCa⟩
+    refine ⟨fun j => continuous_star.measurable.comp (ha j), C,hC, fun x j => ?_⟩
+    simpa using hCa x j
+abbrev DiagonalSymbol := ↥diagonalSymbols
+namespace DiagonalSymbol
+instance : CoeFun DiagonalSymbol (fun _ => Base → ℤ → ℂ) := ⟨fun a => a.val⟩
+lemma measurable (a : DiagonalSymbol) (j : ℤ) : Measurable (fun x => a x j) := a.property.1 j
+noncomputable def bound (a : DiagonalSymbol) : ℝ := a.property.2.choose
+lemma bound_nonneg (a : DiagonalSymbol) : 0 ≤ a.bound := a.property.2.choose_spec.1
+lemma norm_le_bound (a : DiagonalSymbol) (x : Base) (j : ℤ) : ‖a x j‖ ≤ a.bound :=
+  a.property.2.choose_spec.2 x j
+@[simp] lemma zero_apply (x : Base) (j : ℤ) : (0 : DiagonalSymbol) x j = 0 := rfl
+@[simp] lemma one_apply (x : Base) (j : ℤ) : (1 : DiagonalSymbol) x j = 1 := rfl
+@[simp] lemma add_apply (a b : DiagonalSymbol) (x : Base) (j : ℤ) : (a+b) x j = a x j + b x j := rfl
+@[simp] lemma mul_apply (a b : DiagonalSymbol) (x : Base) (j : ℤ) : (a*b) x j = a x j * b x j := rfl
+@[simp] lemma sub_apply (a b : DiagonalSymbol) (x : Base) (j : ℤ) : (a-b) x j = a x j - b x j := rfl
+@[simp] lemma star_apply (a : DiagonalSymbol) (x : Base) (j : ℤ) : (star a) x j = star (a x j) := rfl
+@[simp] lemma smul_apply (c : ℂ) (a : DiagonalSymbol) (x : Base) (j : ℤ) : (c • a) x j = c * a x j := rfl
+@[simp] lemma algebraMap_apply (c : ℂ) (x : Base) (j : ℤ) :
+    algebraMap ℂ DiagonalSymbol c x j = c := rfl
+@[simp] lemma pow_apply (a : DiagonalSymbol) (n : ℕ) (x : Base) (j : ℤ) :
+    (a^n) x j = (a x j)^n := by induction n <;> simp_all [pow_succ]
+end DiagonalSymbol
+
+def diagonalFiber (a : DiagonalSymbol) (x : Base) : Fiber →L[ℂ] Fiber :=
+  fiberMultiplier (a x) a.bound a.bound_nonneg (a.norm_le_bound x)
+@[simp] lemma diagonalFiber_apply (a : DiagonalSymbol) (x : Base) (v : Fiber) (j : ℤ) :
+    diagonalFiber a x v j = a x j*v j := rfl
+lemma diagonalFiber_norm (a : DiagonalSymbol) (x : Base) : ‖diagonalFiber a x‖ ≤ a.bound :=
+  fiberMultiplier_norm_le _ _ _ _
+lemma diagonalFiber_measurable (a : DiagonalSymbol) (f : Base → Fiber)
+    (hf : AEStronglyMeasurable f baseMeasure) :
+    AEStronglyMeasurable (fun x => diagonalFiber a x (f x)) baseMeasure :=
+  weightedPermutation_aestronglyMeasurable (Equiv.refl ℤ) a a.bound a.bound_nonneg
+    a.norm_le_bound a.measurable hf
+
+def diagonalOperator (a : DiagonalSymbol) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  fieldOperator (diagonalFiber a) a.bound a.bound_nonneg (diagonalFiber_norm a)
+    (diagonalFiber_measurable a)
+lemma diagonalOperator_ae (a : DiagonalSymbol) (f : GlobalHilbert) :
+    diagonalOperator a f =ᵐ[baseMeasure] fun x => diagonalFiber a x (f x) :=
+  fieldOperator_ae _ _ _ _ _ _
+lemma diagonalOperator_coord (a : DiagonalSymbol) (f : GlobalHilbert) :
+    ∀ᵐ x ∂baseMeasure, ∀ j, diagonalOperator a f x j = a x j*f x j := by
+  filter_upwards [diagonalOperator_ae a f] with x hx j
+  rw [hx]; rfl
+lemma diagonalOperator_norm_le (a : DiagonalSymbol) {C : ℝ} (hC : 0 ≤ C)
+    (ha : ∀ x j, ‖a x j‖ ≤ C) : ‖diagonalOperator a‖ ≤ C := by
+  apply ContinuousLinearMap.opNorm_le_bound _ hC
+  intro f
+  calc
+    _ ≤ ‖(C:ℂ) • f‖ := by
+      apply Lp.norm_le_norm_of_ae_le
+      filter_upwards [diagonalOperator_ae a f, Lp.coeFn_smul (C:ℂ) f] with x hx hs
+      rw [hx,hs,Pi.smul_apply]
+      apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0)
+      intro j
+      simp only [diagonalFiber_apply,lp.coeFn_smul,Pi.smul_apply,norm_smul,norm_mul,
+        Complex.norm_real,Real.norm_of_nonneg hC]
+      exact mul_le_mul_of_nonneg_right (ha x j) (norm_nonneg _)
+    _ = C*‖f‖ := by rw [norm_smul,Complex.norm_real,Real.norm_of_nonneg hC]
+lemma diagonalOperator_zero : diagonalOperator 0 = 0 := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord 0 f,Lp.coeFn_zero Fiber 2 baseMeasure] with x hx h0
+  ext j
+  change diagonalOperator 0 f x j = (0 : GlobalHilbert) x j
+  rw [hx,h0]; simp
+lemma diagonalOperator_one : diagonalOperator 1 = 1 := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord 1 f] with x hx
+  ext j
+  simpa using hx j
+lemma diagonalOperator_add (a b : DiagonalSymbol) :
+    diagonalOperator (a+b) = diagonalOperator a + diagonalOperator b := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord (a+b) f, diagonalOperator_coord a f,
+    diagonalOperator_coord b f, Lp.coeFn_add (diagonalOperator a f) (diagonalOperator b f)] with x hab ha hb hs
+  ext j
+  change diagonalOperator (a+b) f x j = (diagonalOperator a f + diagonalOperator b f) x j
+  rw [hs,Pi.add_apply,lp.coeFn_add,Pi.add_apply,hab,ha,hb,DiagonalSymbol.add_apply,add_mul]
+lemma diagonalOperator_mul (a b : DiagonalSymbol) :
+    diagonalOperator (a*b) = diagonalOperator a * diagonalOperator b := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord (a*b) f, diagonalOperator_coord a (diagonalOperator b f),
+    diagonalOperator_coord b f] with x hab ha hb
+  ext j
+  change diagonalOperator (a*b) f x j = diagonalOperator a (diagonalOperator b f) x j
+  rw [hab,ha,hb,DiagonalSymbol.mul_apply,mul_assoc]
+lemma diagonalOperator_smul (c : ℂ) (a : DiagonalSymbol) :
+    diagonalOperator (c • a) = c • diagonalOperator a := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord (c • a) f, diagonalOperator_coord a f,
+    Lp.coeFn_smul c (diagonalOperator a f)] with x hca ha hs
+  ext j
+  change diagonalOperator (c • a) f x j = (c • diagonalOperator a f) x j
+  rw [hs,Pi.smul_apply,lp.coeFn_smul,Pi.smul_apply,hca,ha,DiagonalSymbol.smul_apply,smul_eq_mul,mul_assoc]
+lemma diagonalFiber_inner (a : DiagonalSymbol) (x : Base) (v z : Fiber) :
+    inner ℂ (diagonalFiber a x v) z = inner ℂ v (diagonalFiber (star a) x z) := by
+  simp only [lp.inner_eq_tsum]
+  apply tsum_congr
+  intro j
+  simp only [diagonalFiber_apply,DiagonalSymbol.star_apply,RCLike.inner_apply,map_mul,starRingEnd_apply]
+  ring
+lemma diagonalOperator_star (a : DiagonalSymbol) :
+    diagonalOperator (star a) = star (diagonalOperator a) := by
+  ext1 f
+  apply ext_inner_left ℂ
+  intro g
+  change inner ℂ g (diagonalOperator (star a) f) = inner ℂ g ((diagonalOperator a).adjoint f)
+  rw [ContinuousLinearMap.adjoint_inner_right]
+  simp only [L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [diagonalOperator_ae (star a) f, diagonalOperator_ae a g] with x hf hg
+  rw [hf,hg,diagonalFiber_inner]
+
+def diagonalRepresentation : DiagonalSymbol →⋆ₐ[ℂ] (GlobalHilbert →L[ℂ] GlobalHilbert) where
+  toFun := diagonalOperator
+  map_zero' := diagonalOperator_zero
+  map_one' := diagonalOperator_one
+  map_add' := diagonalOperator_add
+  map_mul' := diagonalOperator_mul
+  map_star' := diagonalOperator_star
+  commutes' c := by
+    have he : algebraMap ℂ DiagonalSymbol c = c • (1 : DiagonalSymbol) := by
+      apply Subtype.ext
+      funext x j
+      simp
+    rw [he,diagonalOperator_smul,diagonalOperator_one]
+    exact (Algebra.algebraMap_eq_smul_one c).symm
+
+def fullMultiplierAlgebra : StarSubalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) :=
+  diagonalRepresentation.range
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ErgodicTransitivity.lean

@@ -0,0 +1,380 @@
+import OAI.Analysis.BackwardIntertwiners.GlobalOperators
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+
+
+lemma ergodic_late_intersection {X : Type*} [MeasurableSpace X] {μ : Measure X}
+    [IsFiniteMeasure μ] {θ : X → X} (hθ : Ergodic θ μ)
+    {A B : Set X} (_ : MeasurableSet A) (hB : MeasurableSet B)
+    (hA0 : μ A ≠ 0) (hB0 : μ B ≠ 0) (N : ℕ) :
+    ∃ n : ℕ, N ≤ n ∧ μ (A ∩ (θ^[n]) ⁻¹' B) ≠ 0 := by
+  let U : Set X := ⋃ n : ℕ, (θ^[n+N]) ⁻¹' B
+  have hUmeas : MeasurableSet U := MeasurableSet.iUnion fun n =>
+    hB.preimage (hθ.measurable.iterate (n+N))
+  have hsub : θ ⁻¹' U ⊆ U := by
+    intro x hx
+    obtain ⟨n,hn⟩ := Set.mem_iUnion.mp hx
+    apply Set.mem_iUnion.mpr
+    refine ⟨n+1, ?_⟩
+    change θ^[n+1+N] x ∈ B
+    have hi : n+1+N = (n+N)+1 := by omega
+    rw [hi,Function.iterate_succ_apply]
+    exact hn
+  have hU0 : μ U ≠ 0 := by
+    intro h
+    have hs : (θ^[N]) ⁻¹' B ⊆ U := by
+      intro x hx
+      exact Set.mem_iUnion.mpr ⟨0, by simpa using hx⟩
+    have he := (hθ.toMeasurePreserving.iterate N).measure_preimage hB.nullMeasurableSet
+    exact hB0 (le_antisymm (by rw [← he]; exact (measure_mono hs).trans (by rw [h])) bot_le)
+  have hUfull : U =ᵐ[μ] Set.univ := by
+    obtain he | he := hθ.ae_empty_or_univ_of_preimage_ae_le hUmeas.nullMeasurableSet
+      (Filter.Eventually.of_forall hsub)
+    · exact False.elim (hU0 (by rw [measure_congr he,measure_empty]))
+    · exact he
+  by_contra! hn
+  have hzero : μ (A ∩ U) = 0 := by
+    rw [show A ∩ U = ⋃ n : ℕ, A ∩ (θ^[n+N]) ⁻¹' B from Set.inter_iUnion _ _]
+    exact measure_iUnion_null fun n => hn (n+N) (by omega)
+  have he : (A ∩ U : Set X) =ᵐ[μ] A := by
+    filter_upwards [hUfull] with x hx
+    apply propext
+    change (x ∈ A ∧ x ∈ U) ↔ x ∈ A
+    have hxU : x ∈ U := (eq_iff_iff.mp hx).mpr (Set.mem_univ x)
+    simp [hxU]
+  exact hA0 ((measure_congr he).symm.trans hzero)
+
+section Localization
+variable {X : Type*} [MeasurableSpace X] {μ : Measure X} [finiteMeasure : IsFiniteMeasure μ]
+
+omit finiteMeasure in
+lemma measurable_global_coordinate [IsFiniteMeasure μ] (f : Lp Fiber 2 μ) (j : ℤ) : Measurable (fun x => f x j) :=
+  ((lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).continuous.comp_stronglyMeasurable (Lp.stronglyMeasurable f)).measurable
+
+omit finiteMeasure in
+lemma exists_coordinate_support_nonnull [IsFiniteMeasure μ] {f : Lp Fiber 2 μ} (hf : f ≠ 0) :
+    ∃ j : ℤ, μ {x | f x j ≠ 0} ≠ 0 := by
+  by_contra! h
+  apply hf
+  rw [Lp.eq_zero_iff_ae_eq_zero]
+  have ha : ∀ j : ℤ, ∀ᵐ x ∂μ, f x j = 0 := fun j => by
+    exact ae_iff.mpr (h j)
+  filter_upwards [ae_all_iff.mpr ha] with x hx
+  ext j
+  exact hx j
+
+
+
+
+lemma scalar_invariant_pointwise_orthogonal {L : Submodule ℂ (Lp Fiber 2 μ)}
+    (hL : ∀ g : Lp ℂ ∞ μ, ∀ f ∈ L, scalarMultiplier g f ∈ L)
+    {f z : Lp Fiber 2 μ} (hf : f ∈ L) (hz : z ∈ L.orthogonal) :
+    ∀ᵐ x ∂μ, inner ℂ (z x) (f x) = 0 := by
+  apply (L2.integrable_inner z f).ae_eq_zero_of_forall_setIntegral_eq_zero
+  intro s hs _
+  let g : Lp ℂ ∞ μ := indicatorConstLp ∞ hs (measure_ne_top μ s) (1:ℂ)
+  have hg : g =ᵐ[μ] s.indicator (fun _ => (1:ℂ)) := indicatorConstLp_coeFn
+  rw [← integral_indicator hs]
+  calc
+    _ = ∫ x, inner ℂ (z x) (scalarMultiplier g f x) ∂μ := by
+      apply integral_congr_ae
+      filter_upwards [scalarMultiplier_ae g f, hg] with x hx hgx
+      rw [hx,hgx]
+      by_cases hxs : x ∈ s
+      · simp [Set.indicator_of_mem hxs]
+      · simp [Set.indicator_of_notMem hxs]
+    _ = inner ℂ z (scalarMultiplier g f) := (L2.inner_def _ _).symm
+    _ = 0 := Submodule.inner_left_of_mem_orthogonal (hL g f hf) hz
+end Localization
+
+lemma fiber_cyclic_orthogonal_order {w : ℤ → ℝ} (hw : QuadraticWeights w)
+    {T : Fiber →L[ℂ] Fiber}
+    (hT : ∀ v j, T v j = (w j / w (j-1) : ℂ) * v (j-1))
+    {v z : Fiber} (horth : ∀ r : ℕ, inner ℂ z ((T^r) v) = 0)
+    {i j : ℤ} (hzi : z i ≠ 0) (hvj : v j ≠ 0) : i < j := by
+  let b := fun k : ℤ => star (z k) * (w k:ℂ)
+  let c := fun k : ℤ => v k / (w k:ℂ)
+  have hwC (k : ℤ) : (w k:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt (hw.positive k))
+  have hbi : b i ≠ 0 := mul_ne_zero (by simpa using hzi) (hwC i)
+  have hcj : c j ≠ 0 := div_ne_zero hvj (hwC j)
+  have hb (k : ℤ) : ‖b k‖ ≤ (‖z‖+1)*w k := by
+    dsimp [b]
+    rw [norm_mul, RCLike.norm_conj, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le]
+    apply mul_le_mul_of_nonneg_right _ (hw.positive k).le
+    exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) z k).trans (by linarith)
+  have hc (k : ℤ) : ‖c k‖*w k ≤ ‖v‖+1 := by
+    dsimp [c]
+    rw [norm_div, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le,
+      div_mul_cancel₀ _ (ne_of_gt (hw.positive k))]
+    exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) v k).trans (by linarith)
+  have hcor (r : ℕ) : (∑' k : ℤ, b k*c (k-r)) = 0 := by
+    calc (∑' k : ℤ, b k*c (k-r)) = inner ℂ z ((T^r) v) := by
+          rw [lp.inner_eq_tsum]
+          apply tsum_congr
+          intro k
+          rw [RCLike.inner_apply, weighted_shift_pow hw.positive hT]
+          dsimp [b, c]
+          simp only [← Complex.star_def]
+          ring
+      _ = 0 := horth r
+  exact (quadratic_support_separation w hw).strict_order ⟨i,hbi⟩ ⟨j,hcj⟩
+    (by positivity : 0 < ‖z‖+1) (by positivity : 0 < ‖v‖+1) hb hc hcor hbi hcj
+
+
+lemma explicitWeight_quadratic (x : Base) : QuadraticWeights (explicitWeight x) :=
+  bilateralWeight_quadratic (plusResidue_bounds x) (minusResidue_bounds x)
+
+lemma forwardFiber_weight_coordinates (x : Base) (v : Fiber) (j : ℤ) :
+    forwardFiber x v j = (explicitWeight x j / explicitWeight x (j-1) : ℂ) * v (j-1) := by
+  rw [forwardFiber_apply, ← explicitWeight_ratio x (j-1)]
+  simp only [sub_add_cancel, Complex.ofReal_div]
+
+lemma forwardFiber_lattice (x : Base) (L : Submodule ℂ Fiber) :
+    (IsClosed (L : Set Fiber) ∧ OperatorInvariant L (forwardFiber x)) ↔
+      L = ⊥ ∨ L = ⊤ ∨ ∃ h : ℤ, L = coordinateTail h := by
+  constructor
+  · rintro ⟨hcl, hinv⟩
+    exact quadratic_fiber_tails _ (explicitWeight_quadratic x) _ (forwardFiber_weight_coordinates x) L hcl hinv
+  · rintro (rfl | rfl | ⟨h,rfl⟩)
+    · refine ⟨?_, ?_⟩
+      · simpa only [Submodule.bot_coe] using (isClosed_singleton : IsClosed ({0} : Set Fiber))
+      · intro v hv
+        simpa only [Submodule.mem_bot, map_zero] using congrArg (forwardFiber x) (show v = 0 from hv)
+    · exact ⟨isClosed_univ, fun _ _ => trivial⟩
+    · exact ⟨coordinateTail_isClosed h, fun _ hv => forwardFiber_tail x h hv⟩
+
+lemma inverseOdometer_ergodic : Ergodic inverseOdometer baseMeasure :=
+  Ergodic.symm (e := odometerMeasurableEquiv) odometer_ergodic
+
+lemma backwardOperator_power_nonzero (n : ℕ) (f : GlobalHilbert) (j : ℤ) :
+    ∀ᵐ x ∂baseMeasure, f (inverseOdometer^[n] x) j ≠ 0 →
+      ((backwardOperator^n) f) x (j-n) ≠ 0 := by
+  induction n with
+  | zero => filter_upwards [] with x; simp
+  | succ n ih =>
+    rw [pow_succ', mul_apply_eq_comp]
+    filter_upwards [backwardOperator_ae_inverse ((backwardOperator^n) f),
+      inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually ih,
+      inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually backwardCoeff_ae_pos]
+      with x hx hi hp
+    intro hn
+    rw [hx, backwardFiber_apply]
+    have he : j - (n+1:ℕ) + 1 = j - n := by omega
+    rw [he]
+    apply mul_ne_zero
+    · exact_mod_cast (ne_of_gt (hp (j-n)))
+    · apply hi
+      simpa only [Function.iterate_succ_apply] using hn
+
+lemma global_invariant_pow {T : GlobalHilbert →L[ℂ] GlobalHilbert}
+    {L : Submodule ℂ GlobalHilbert} (hi : OperatorInvariant L T)
+    {v : GlobalHilbert} (hv : v ∈ L) (n : ℕ) : (T^n) v ∈ L := by
+  induction n with
+  | zero => simpa using hv
+  | succ n ih => simpa only [pow_succ', mul_apply_eq_comp] using hi _ ih
+
+lemma invariant_pointwise_order {L : Submodule ℂ GlobalHilbert}
+    (hS : OperatorInvariant L forwardOperator)
+    (hM : ∀ g : Lp ℂ ∞ baseMeasure, OperatorInvariant L (scalarMultiplier g))
+    {f z : GlobalHilbert} (hf : f ∈ L) (hz : z ∈ L.orthogonal) :
+    ∀ᵐ x ∂baseMeasure, ∀ i j : ℤ, z x i ≠ 0 → f x j ≠ 0 → i < j := by
+  have horth (r : ℕ) : ∀ᵐ x ∂baseMeasure, inner ℂ (z x) (((forwardOperator^r) f) x) = 0 :=
+    scalar_invariant_pointwise_orthogonal hM (global_invariant_pow hS hf r) hz
+  filter_upwards [ae_all_iff.mpr horth,
+    ae_all_iff.mpr (fun r => forwardOperator_power_ae r f)] with x hx hxpow
+  intro i j hzi hfj
+  apply fiber_cyclic_orthogonal_order (explicitWeight_quadratic x) (forwardFiber_weight_coordinates x) ?_ hzi hfj
+  intro r
+  rw [← hxpow r]
+  exact hx r
+
+
+
+
+lemma forward_backward_scalar_transitive (L : Submodule ℂ GlobalHilbert)
+    (hclosed : IsClosed (L : Set GlobalHilbert))
+    (hS : OperatorInvariant L forwardOperator)
+    (hV : OperatorInvariant L backwardOperator)
+    (hM : ∀ g : Lp ℂ ∞ baseMeasure, OperatorInvariant L (scalarMultiplier g)) :
+    L = ⊥ ∨ L = ⊤ := by
+  by_contra! hproper
+  have hOO : L.orthogonal.orthogonal = L := by
+    rw [Submodule.orthogonal_orthogonal_eq_closure, hclosed.submodule_topologicalClosure_eq]
+  have hnotOrth : L.orthogonal ≠ ⊥ := by
+    intro hh
+    rw [hh, Submodule.bot_orthogonal_eq_top] at hOO
+    exact hproper.2 hOO.symm
+  obtain ⟨f,hf,hf0⟩ := (Submodule.ne_bot_iff L).mp hproper.1
+  obtain ⟨z,hz,hz0⟩ := (Submodule.ne_bot_iff L.orthogonal).mp hnotOrth
+  obtain ⟨j,hA0⟩ := exists_coordinate_support_nonnull hf0
+  obtain ⟨i,hB0⟩ := exists_coordinate_support_nonnull hz0
+  let A : Set Base := {x | f x j ≠ 0}
+  let B : Set Base := {x | z x i ≠ 0}
+  have hA : MeasurableSet A := (measurableSet_eq_fun (measurable_global_coordinate f j) measurable_const).compl
+  have hB : MeasurableSet B := (measurableSet_eq_fun (measurable_global_coordinate z i) measurable_const).compl
+  obtain ⟨n,hn,hinter⟩ := ergodic_late_intersection inverseOdometer_ergodic hB hA hB0 hA0 (j-i).toNat
+  have horder := invariant_pointwise_order hS hM (global_invariant_pow hV hf n) hz
+  have hnull : ∀ᵐ x ∂baseMeasure, x ∉ B ∩ (inverseOdometer^[n]) ⁻¹' A := by
+    filter_upwards [horder, backwardOperator_power_nonzero n f j] with x hx hp
+    intro hmem
+    have hzi : z x i ≠ 0 := hmem.1
+    have hfj : f (inverseOdometer^[n] x) j ≠ 0 := hmem.2
+    have hh := hx i (j-n) hzi (hp hfj)
+    have hnat : (j-i) ≤ ((j-i).toNat : ℤ) := by omega
+    have hnn : ((j-i).toNat : ℤ) ≤ (n:ℤ) := by exact_mod_cast hn
+    omega
+  apply hinter
+  convert ae_iff.mp hnull using 1
+  congr 1
+  ext x
+  simp only [Set.mem_ofPred_eq, not_not]
+
+lemma generated_transitive : AlgebraTransitive (generatedAlgebra forwardOperator backwardOperator) := by
+  intro L hclosed hInv
+  apply forward_backward_scalar_transitive L hclosed
+  · exact hInv _ (Algebra.subset_adjoin (Or.inl (Set.mem_insert _ _)))
+  · exact hInv _ (Algebra.subset_adjoin (Or.inl (Set.mem_insert_of_mem _ (Set.mem_singleton _))))
+  · intro g
+    exact hInv _ (Algebra.subset_adjoin (Or.inr ⟨g,rfl⟩))
+
+
+def explicitDirectModel : DirectModelData :=
+  ⟨forwardFiber, forwardOperator, backwardCoeff, backwardFiber, backwardOperator⟩
+
+lemma explicitDirectModel_properties : DirectModelProperties explicitDirectModel where
+  beta_measurable := measurable_explicitBeta
+  beta_positive := explicitBeta_pos
+  forward_coordinates := forwardFiber_apply
+  forward_field := forwardOperator_ae
+  fiber_lattice := forwardFiber_lattice
+  S_nonzero := forwardOperator_ne_zero
+  S_norm := forwardOperator_norm
+  power_bound := fun n _ => forwardOperator_power_norm n
+  V_contraction := backwardOperator_norm
+  commute := forward_backward_commute
+  backward_measurable := measurable_backwardCoeff
+  backward_bounds := backwardCoeff_bounds
+  backward_coordinates := backwardFiber_apply
+  backward_field := backwardOperator_ae
+  common_conull := by
+    refine ⟨goodBase, measurableSet_goodBase, ?_, ?_, ?_⟩
+    · exact ae_iff.mp ae_goodBase
+    · ext x
+      exact goodBase_odometer x
+    · intro x hx
+      exact ⟨backwardCoeff_pos hx, backwardFiber_tail_closure hx, backwardFiber_denseRange hx⟩
+  transitive := generated_transitive
+
+theorem direct_model : ∃ D : DirectModelData, DirectModelProperties D :=
+  ⟨explicitDirectModel, explicitDirectModel_properties⟩
+
+def rankOneCoordinate (i j : ℤ) : Fiber →L[ℂ] Fiber :=
+  (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 i).comp (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j)
+@[simp] lemma rankOneCoordinate_apply (i j : ℤ) (v : Fiber) :
+    rankOneCoordinate i j v = lp.single 2 i (v j) := rfl
+lemma rankOneCoordinate_compact (i j : ℤ) : IsCompactOperator (rankOneCoordinate i j) :=
+  (isCompactOperator_of_locallyCompactSpace_dom (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j)).clm_comp
+    (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 i)
+
+def finiteShift (x : Base) (n : ℕ) : Fiber →L[ℂ] Fiber :=
+  ∑ j ∈ Finset.Icc (-(n:ℤ)) n, (explicitBeta x j:ℂ) • rankOneCoordinate (j+1) j
+lemma finiteShift_compact (x : Base) (n : ℕ) : IsCompactOperator (finiteShift x n) := by
+  change finiteShift x n ∈ compactOperator (RingHom.id ℂ) Fiber Fiber
+  exact Submodule.sum_mem _ fun j hj => Submodule.smul_mem _ _ (rankOneCoordinate_compact (j+1) j)
+lemma finiteShift_apply (x : Base) (n : ℕ) (v : Fiber) (j : ℤ) :
+    finiteShift x n v (j+1) = if j ∈ Finset.Icc (-(n:ℤ)) n then (explicitBeta x j:ℂ) * v j else 0 := by
+  classical
+  simp only [finiteShift, sum_apply, smul_apply,
+    lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply, rankOneCoordinate_apply]
+  by_cases hj : j ∈ Finset.Icc (-(n:ℤ)) n
+  · rw [ite_eq_left hj, Finset.sum_eq_single_of_mem j hj]
+    · simp only [lp.single_apply_self, smul_eq_mul]
+    · intro k hk hkj
+      rw [lp.single_apply_ne _ _ _ (by omega), smul_zero]
+  · rw [ite_eq_right hj]
+    apply Finset.sum_eq_zero
+    intro k hk
+    have hkj : j+1 ≠ k+1 := by
+      intro hh
+      have he : j=k := by omega
+      subst k
+      exact hj hk
+    rw [lp.single_apply_ne _ _ _ hkj, smul_zero]
+lemma explicitBeta_outside_bound (x : Base) (n : ℕ) (j : ℤ)
+    (hj : j ∉ Finset.Icc (-(n:ℤ)) n) : explicitBeta x j ≤ Real.exp (-10*(n:ℝ)) := by
+  apply Real.exp_le_exp.mpr
+  change -explicitExponent x j ≤ -10*(n:ℝ)
+  have hd := explicitExponent_distance x j
+  have hh : (n:ℤ) ≤ coordinateDistance j := by
+    simp only [Finset.mem_Icc, not_and_or, not_le] at hj
+    rcases hj with hj | hj
+    · exact (by omega : (n:ℤ) ≤ -j).trans (le_max_right _ _)
+    · exact (by omega : (n:ℤ) ≤ j+1).trans (le_max_left _ _)
+  have hR : (n:ℝ) ≤ (coordinateDistance j : ℝ) := by exact_mod_cast hh
+  linarith
+lemma finiteShift_error (x : Base) (n : ℕ) :
+    ‖forwardFiber x - finiteShift x n‖ ≤ Real.exp (-10*(n:ℝ)) := by
+  let C := Real.exp (-10*(n:ℝ))
+  have hC : 0 ≤ C := (Real.exp_pos _).le
+  apply ContinuousLinearMap.opNorm_le_bound _ hC
+  intro v
+  calc
+    _ ≤ ‖(C:ℂ) • v‖ := by
+      let vr := fiberReindex (Equiv.addRight (1:ℤ)) ((forwardFiber x - finiteShift x n) v)
+      rw [← (fiberReindex (Equiv.addRight (1:ℤ))).norm_map ((forwardFiber x - finiteShift x n) v)]
+      apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0)
+      intro j
+      change ‖(forwardFiber x - finiteShift x n) v (j+1)‖ ≤ ‖(C:ℂ) * v j‖
+      rw [sub_apply, lp.coeFn_sub, Pi.sub_apply, forwardFiber_apply, add_sub_cancel_right, finiteShift_apply]
+      by_cases hj : j ∈ Finset.Icc (-(n:ℤ)) n
+      · rw [ite_eq_left hj, sub_self, norm_zero]
+        exact norm_nonneg _
+      · rw [ite_eq_right hj, sub_zero, norm_mul, norm_mul, Complex.norm_real, Complex.norm_real,
+          Real.norm_of_nonneg (explicitBeta_pos x j).le, Real.norm_of_nonneg hC]
+        exact mul_le_mul_of_nonneg_right (explicitBeta_outside_bound x n j hj) (norm_nonneg _)
+    _ = C*‖v‖ := by rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg hC]
+lemma forwardFiber_compact (x : Base) : IsCompactOperator (forwardFiber x) := by
+  apply isCompactOperator_of_tendsto (l:=atTop) (F:=finiteShift x) ?_ (Filter.Eventually.of_forall (finiteShift_compact x))
+  rw [tendsto_iff_norm_sub_tendsto_zero]
+  have he : Tendsto (fun n : ℕ => Real.exp (-10*(n:ℝ))) atTop (𝓝 0) := by
+    apply Real.tendsto_exp_atBot.comp
+    exact tendsto_const_nhds.neg_mul_atTop (by norm_num) tendsto_natCast_atTop_atTop
+  apply squeeze_zero (fun _ => norm_nonneg _) ?_ he
+  intro n
+  rw [norm_sub_rev]
+  exact finiteShift_error x n
+
+abbrev ScalarHilbert := Lp ℂ 2 baseMeasure
+
+def coordinateL2 (j : ℤ) : GlobalHilbert →L[ℂ] ScalarHilbert :=
+  (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).compLpL 2 baseMeasure
+
+def singleL2 (j : ℤ) : ScalarHilbert →L[ℂ] GlobalHilbert :=
+  (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 j).compLpL 2 baseMeasure
+
+lemma coordinateL2_ae (j : ℤ) (f : GlobalHilbert) :
+    coordinateL2 j f =ᵐ[baseMeasure] fun x => f x j :=
+  ContinuousLinearMap.coeFn_compLpL _ _
+lemma singleL2_ae (j : ℤ) (f : ScalarHilbert) :
+    singleL2 j f =ᵐ[baseMeasure] fun x => lp.single 2 j (f x) :=
+  ContinuousLinearMap.coeFn_compLpL _ _
+lemma coordinateL2_singleL2 (j : ℤ) (f : ScalarHilbert) :
+    coordinateL2 j (singleL2 j f) = f := by
+  apply Lp.ext
+  filter_upwards [coordinateL2_ae j (singleL2 j f), singleL2_ae j f] with x h₁ h₂
+  simp only [h₁, h₂, lp.single_apply_self]
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ExplicitWeights.lean

@@ -0,0 +1,288 @@
+import OAI.Analysis.BackwardIntertwiners.FiberTails
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+
+def weightBlock (k : ℕ) : ℕ := Nat.log 8 k + 1
+def residueScale (k : ℕ) : ℕ := 2 ^ weightBlock k
+
+def residueCorrection (t : ℕ → ℕ) (k : ℕ) : ℝ :=
+  if k = 0 then 0 else 100 * ((residueScale k : ℝ) - 2 + t (weightBlock k))
+def halfExponent (t : ℕ → ℕ) (k : ℕ) : ℝ :=
+  10 * ((k : ℝ) + 1) + residueCorrection t k
+
+def ResidueBounds (t : ℕ → ℕ) : Prop := ∀ m, t m < 2 ^ m
+
+lemma residueScale_ge_two (k : ℕ) : 2 ≤ residueScale k := by
+  dsimp [residueScale, weightBlock]
+  simpa using (Nat.pow_le_pow_right (by norm_num : 0 < 2) (by omega : 1 ≤ Nat.log 8 k + 1))
+
+lemma residueCorrection_nonneg (t : ℕ → ℕ) (k : ℕ) : 0 ≤ residueCorrection t k := by
+  dsimp [residueCorrection]
+  split_ifs
+  · rfl
+  · have hh : (2:ℝ) ≤ residueScale k := by exact_mod_cast residueScale_ge_two k
+    positivity
+
+lemma residueCorrection_le {t : ℕ → ℕ} (ht : ResidueBounds t) (k : ℕ) :
+    residueCorrection t k ≤ 200 * residueScale k := by
+  have hN : (0:ℝ) ≤ residueScale k := Nat.cast_nonneg _
+  dsimp [residueCorrection]
+  split_ifs
+  · positivity
+  · have hr : (t (weightBlock k):ℝ) < residueScale k := by exact_mod_cast ht (weightBlock k)
+    linarith
+
+lemma residueCorrection_mono {t : ℕ → ℕ} (ht : ResidueBounds t) :
+    Monotone (residueCorrection t) := by
+  intro k l hkl
+  by_cases hk : k = 0
+  · simpa [hk, residueCorrection] using residueCorrection_nonneg t l
+  have hl : l ≠ 0 := by omega
+  have hq : weightBlock k ≤ weightBlock l := Nat.add_le_add_right (Nat.log_mono_right hkl) 1
+  dsimp only [residueCorrection]
+  rw [ite_eq_right hk, ite_eq_right hl]
+  rcases hq.eq_or_lt with hq | hq
+  · simp [hq, residueScale]
+  · have hNN : 2 * residueScale k ≤ residueScale l := by
+      dsimp [residueScale]
+      rw [← pow_succ']
+      exact Nat.pow_le_pow_right (by norm_num) (by omega)
+    have hNk : (2 * residueScale k : ℝ) ≤ residueScale l := by exact_mod_cast hNN
+    have htk : (t (weightBlock k) : ℝ) < residueScale k := by exact_mod_cast ht _
+    have htl : (0:ℝ) ≤ t (weightBlock l) := Nat.cast_nonneg _
+    linarith
+
+lemma halfExponent_mono {t : ℕ → ℕ} (ht : ResidueBounds t) : Monotone (halfExponent t) := by
+  intro k l hkl
+  have hc := residueCorrection_mono ht hkl
+  have hkl' : (k:ℝ) ≤ l := by exact_mod_cast hkl
+  dsimp [halfExponent]
+  linarith
+
+lemma halfExponent_lower (t : ℕ → ℕ) (k : ℕ) :
+    10*((k:ℝ)+1) ≤ halfExponent t k := by
+  have hh := residueCorrection_nonneg t k
+  dsimp [halfExponent]
+  linarith
+
+@[simp] lemma halfExponent_zero (t : ℕ → ℕ) : halfExponent t 0 = 10 := by
+  norm_num [halfExponent, residueCorrection]
+
+lemma residueScale_sq_le {k : ℕ} (hk : k ≠ 0) : (residueScale k)^2 ≤ 4*k := by
+  let q := Nat.log 8 k
+  have hq : 8 ^ q ≤ k := Nat.pow_log_le_self 8 hk
+  have h4 : 4 ^ q ≤ 8 ^ q := Nat.pow_le_pow_left (by norm_num) q
+  have he : (residueScale k)^2 = 4 * 4 ^ q := by
+    change (2 ^ (q+1))^2 = 4 * 4^q
+    rw [pow_succ (2:ℕ) q, mul_pow, ← pow_mul, mul_comm q 2, pow_mul]
+    norm_num
+    ring
+  rw [he]
+  omega
+
+lemma residueCorrection_sqrt_bound {t : ℕ → ℕ} (ht : ResidueBounds t) (k : ℕ) :
+    residueCorrection t k ≤ 400 * Real.sqrt k := by
+  by_cases hk : k = 0
+  · simp [hk, residueCorrection]
+  have hs : (residueScale k : ℝ)^2 ≤ 4*(k:ℝ) := by exact_mod_cast residueScale_sq_le hk
+  have hroot := Real.sq_sqrt (Nat.cast_nonneg k : (0:ℝ) ≤ k)
+  have hroot0 := Real.sqrt_nonneg (k:ℝ)
+  have hN0 : (0:ℝ) ≤ residueScale k := Nat.cast_nonneg _
+  have hNr : (residueScale k : ℝ) ≤ 2*Real.sqrt k := by nlinarith
+  exact (residueCorrection_le ht k).trans (by linarith)
+
+def halfSum (t : ℕ → ℕ) (n : ℕ) : ℝ := ∑ k ∈ Finset.range n, halfExponent t k
+
+@[simp] lemma halfSum_zero (t : ℕ → ℕ) : halfSum t 0 = 0 := by simp [halfSum]
+@[simp] lemma halfSum_succ (t : ℕ → ℕ) (n : ℕ) :
+    halfSum t (n+1) = halfSum t n + halfExponent t n := by simp [halfSum, Finset.sum_range_succ]
+
+lemma halfSum_linear (n : ℕ) :
+    (∑ k ∈ Finset.range n, (10:ℝ)*((k:ℝ)+1)) = 5*(n:ℝ)*((n:ℝ)+1) := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [Finset.sum_range_succ, ih]
+    push_cast
+    ring
+
+lemma halfSum_bounds {t : ℕ → ℕ} (ht : ResidueBounds t) (n : ℕ) :
+    5*(n:ℝ)*((n:ℝ)+1) ≤ halfSum t n ∧
+    halfSum t n ≤ 5*(n:ℝ)*((n:ℝ)+1) + 400*(n:ℝ)*Real.sqrt n := by
+  have he : halfSum t n = 5*(n:ℝ)*((n:ℝ)+1) +
+      ∑ k ∈ Finset.range n, residueCorrection t k := by
+    simp only [halfSum, halfExponent, Finset.sum_add_distrib, halfSum_linear]
+  rw [he]
+  constructor
+  · exact le_add_of_nonneg_right (Finset.sum_nonneg (fun k _ => residueCorrection_nonneg t k))
+  · have hh : (∑ k ∈ Finset.range n, residueCorrection t k) ≤
+        ��� _k ∈ Finset.range n, 400*Real.sqrt n := by
+      apply Finset.sum_le_sum
+      intro k hk
+      have hkn : (k:ℝ) ≤ n := by exact_mod_cast (Finset.mem_range.mp hk).le
+      exact (residueCorrection_sqrt_bound ht k).trans
+        (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hkn) (by norm_num))
+    simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul] at hh
+    nlinarith
+
+lemma halfSum_quadratic {t : ℕ → ℕ} (ht : ResidueBounds t) :
+    Tendsto (fun n : ℕ => halfSum t n / (n:ℝ)^2) atTop (𝓝 5) := by
+  have hn : Tendsto (fun n : ℕ => (n:ℝ)) atTop atTop := tendsto_natCast_atTop_atTop
+  have hi : Tendsto (fun n : ℕ => (n:ℝ)⁻¹) atTop (𝓝 0) := tendsto_inv_atTop_zero.comp hn
+  have hs : Tendsto (fun n : ℕ => (Real.sqrt (n:ℝ))⁻¹) atTop (𝓝 0) :=
+    tendsto_inv_atTop_zero.comp (Real.tendsto_sqrt_atTop.comp hn)
+  have hz : Tendsto (fun n : ℕ => halfSum t n / (n:ℝ)^2 - 5) atTop (𝓝 0) := by
+    apply squeeze_zero' (g := fun n : ℕ => 5*(n:ℝ)⁻¹ + 400*(Real.sqrt (n:ℝ))⁻¹) ?_ ?_
+      (by simpa using (hi.const_mul 5).add (hs.const_mul 400))
+    · filter_upwards [eventually_ge_atTop 1] with n hn
+      have hn0 : (0:ℝ) < n := by exact_mod_cast (by omega : 0 < n)
+      have hh := (halfSum_bounds ht n).1
+      have hdiv := (le_div_iff₀ (sq_pos_of_pos hn0)).mpr (show 5*(n:ℝ)^2 ≤ halfSum t n by nlinarith)
+      linarith
+    · filter_upwards [eventually_ge_atTop 1] with n hn
+      have hn0 : (0:ℝ) < n := by exact_mod_cast (by omega : 0 < n)
+      have hr0 : 0 < Real.sqrt (n:ℝ) := Real.sqrt_pos.mpr hn0
+      have hr := Real.sq_sqrt hn0.le
+      have hh := (halfSum_bounds ht n).2
+      have he : (5*(n:ℝ)*((n:ℝ)+1) + 400*(n:ℝ)*Real.sqrt n) / (n:ℝ)^2 - 5 =
+          5*(n:ℝ)⁻¹ + 400*(Real.sqrt (n:ℝ))⁻¹ := by
+        field_simp
+        nlinarith
+      rw [← he]
+      exact sub_le_sub_right (div_le_div_of_nonneg_right hh (sq_nonneg _)) 5
+  simpa only [sub_add_cancel, zero_add] using hz.add_const 5
+
+
+def bilateralExponent (t u : ℕ → ℕ) : ℤ → ℝ
+  | .ofNat n => halfExponent t n
+  | .negSucc n => halfExponent u n
+
+def bilateralBeta (t u : ℕ → ℕ) (j : ℤ) : ℝ := Real.exp (-bilateralExponent t u j)
+
+
+def bilateralWeight (t u : ℕ → ℕ) : ℤ → ℝ
+  | .ofNat n => Real.exp (-halfSum t n)
+  | .negSucc n => Real.exp (halfSum u (n+1))
+
+@[simp] lemma bilateralWeight_nat (t u : ℕ → ℕ) (n : ℕ) :
+    bilateralWeight t u n = Real.exp (-halfSum t n) := rfl
+@[simp] lemma bilateralWeight_neg_nat (t u : ℕ → ℕ) (n : ℕ) :
+    bilateralWeight t u (-(n:ℤ)) = Real.exp (halfSum u n) := by
+  cases n with
+  | zero => simp [bilateralWeight]
+  | succ n => rfl
+
+lemma bilateralExponent_nonneg (t u : ℕ → ℕ) (j : ℤ) : 10 ≤ bilateralExponent t u j := by
+  cases j with
+  | ofNat n =>
+    have hh := halfExponent_lower t n
+    change 10 ≤ halfExponent t n
+    have hn : (0:ℝ) ≤ n := Nat.cast_nonneg _
+    linarith
+  | negSucc n =>
+    have hh := halfExponent_lower u n
+    change 10 ≤ halfExponent u n
+    have hn : (0:ℝ) ≤ n := Nat.cast_nonneg _
+    linarith
+
+lemma bilateralWeight_pos (t u : ℕ → ℕ) (j : ℤ) : 0 < bilateralWeight t u j := by
+  cases j <;> exact Real.exp_pos _
+
+lemma bilateralWeight_ratio (t u : ℕ → ℕ) (j : ℤ) :
+    bilateralWeight t u (j+1) / bilateralWeight t u j = bilateralBeta t u j := by
+  cases j with
+  | ofNat n =>
+    change Real.exp (-halfSum t (n+1)) / Real.exp (-halfSum t n) = Real.exp (-halfExponent t n)
+    rw [← Real.exp_sub, halfSum_succ]
+    congr 1
+    ring
+  | negSucc n =>
+    cases n with
+    | zero =>
+      change Real.exp (-halfSum t 0) / Real.exp (halfSum u 1) = Real.exp (-halfExponent u 0)
+      simp [halfSum_succ, Real.exp_neg]
+    | succ n =>
+      change Real.exp (halfSum u (n+1)) / Real.exp (halfSum u (n+1+1)) = Real.exp (-halfExponent u (n+1))
+      rw [← Real.exp_sub, halfSum_succ u (n+1)]
+      congr 1
+      ring
+
+lemma bilateralWeight_antitone (t u : ℕ → ℕ) : Antitone (bilateralWeight t u) := by
+  apply antitone_int_of_succ_le
+  intro j
+  have hr := bilateralWeight_ratio t u j
+  have he : bilateralBeta t u j ≤ 1 := by
+    rw [bilateralBeta, Real.exp_le_one_iff]
+    have hh := bilateralExponent_nonneg t u j
+    linarith
+  exact (div_le_one (bilateralWeight_pos t u j)).mp (hr.le.trans he)
+
+lemma halfSum_discreteConvex {t : ℕ → ℕ} (ht : ResidueBounds t) : DiscreteConvex (halfSum t) := by
+  unfold DiscreteConvex
+  simpa only [halfSum_succ, add_sub_cancel_left] using halfExponent_mono ht
+
+lemma halfSum_root_bound {t : ℕ → ℕ} (ht : ResidueBounds t) {n : ℕ} (hn : 0 < n) :
+    -halfSum t n / (n:ℝ) ≤ -5*(n:ℝ) := by
+  have hn' : (0:ℝ) < n := Nat.cast_pos.mpr hn
+  apply (div_le_iff₀ hn').mpr
+  have hh := (halfSum_bounds ht n).1
+  nlinarith
+
+lemma bilateralWeight_roots_summable {t u : ℕ → ℕ} (ht : ResidueBounds t) (hu : ResidueBounds u) :
+    Summable (fun j : ℤ => if j = 0 then (0:ℝ) else bilateralWeight t u j ^ (1/(j:��))) := by
+  have hs : Summable (fun n : ℕ => Real.exp (-5*(n:ℝ))) := by
+    simpa only [mul_comm (-5:ℝ)] using Real.summable_exp_nat_mul_iff.mpr (by norm_num : (-5:ℝ) < 0)
+  apply Summable.of_nat_of_neg_add_one
+  · apply hs.of_nonneg_of_le
+    · intro n
+      split_ifs
+      · rfl
+      · exact Real.rpow_nonneg (bilateralWeight_pos t u _).le _
+    · intro n
+      by_cases hn : n = 0
+      · simp [hn]
+      · rw [ite_eq_right (by exact_mod_cast hn), bilateralWeight_nat, ← Real.exp_mul]
+        apply Real.exp_le_exp.mpr
+        simpa only [mul_one_div, Int.cast_natCast] using halfSum_root_bound ht (Nat.pos_of_ne_zero hn)
+  · have hs' : Summable (fun n : ℕ => Real.exp (-5*((n:ℝ)+1))) := by
+      simpa only [mul_add, mul_one, Real.exp_add] using hs.mul_right (Real.exp (-5))
+    apply hs'.of_nonneg_of_le
+    · intro n
+      split_ifs
+      · rfl
+      · exact Real.rpow_nonneg (bilateralWeight_pos t u _).le _
+    · intro n
+      have hj : -((n:ℤ)+1) = -((n+1:ℕ):ℤ) := by omega
+      rw [hj, ite_eq_right (by omega), bilateralWeight_neg_nat, ← Real.exp_mul]
+      apply Real.exp_le_exp.mpr
+      have hb := halfSum_root_bound hu (Nat.zero_lt_succ n)
+      convert hb using 1 <;>
+        simp only [Int.cast_neg, Int.cast_add, Int.cast_one, Int.cast_natCast, Nat.succ_eq_add_one, inv_neg,
+          div_eq_mul_inv, Nat.cast_add, Nat.cast_one] ; ring
+
+lemma bilateralWeight_quadratic {t u : ℕ → ℕ} (ht : ResidueBounds t) (hu : ResidueBounds u) :
+    QuadraticWeights (bilateralWeight t u) where
+  positive := bilateralWeight_pos t u
+  decreasing := bilateralWeight_antitone t u
+  convex_negative := by
+    simpa only [bilateralWeight_neg_nat, Real.log_exp] using halfSum_discreteConvex hu
+  concave_positive := by
+    simpa only [bilateralWeight_nat, Real.log_exp, neg_neg] using halfSum_discreteConvex ht
+  root_sum := bilateralWeight_roots_summable ht hu
+  quadratic := by
+    refine ⟨5, ?_, ?_, ?_⟩
+    · exact (Real.log_lt_sub_one_of_pos (by norm_num) (by norm_num : (3:ℝ) ≠ 1)).trans (by norm_num)
+    · simpa only [bilateralWeight_nat, Real.log_exp, neg_div] using (halfSum_quadratic ht).neg
+    · simpa only [bilateralWeight_neg_nat, Real.log_exp] using halfSum_quadratic hu
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/FiberMaps.lean

@@ -0,0 +1,159 @@
+import OAI.Analysis.BackwardIntertwiners.HaarBase
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+def coordinateDistance (j : ℤ) : ℤ := max (j+1) (-j)
+def powerCost (n : ℕ) : ℕ := (n+1)^2/4
+
+lemma powerCost_add_two (n : ℕ) : powerCost (n+2) = powerCost n + n+2 := by
+  unfold powerCost
+  have he : (n+2+1)^2 = (n+1)^2 + 4*(n+2) := by ring
+  rw [he]
+  omega
+
+lemma coordinateDistance_pos (j : ℤ) : 1 ≤ coordinateDistance j := by
+  unfold coordinateDistance
+  omega
+
+lemma coordinateDistance_endpoints (j : ℤ) (n : ℕ) :
+    (n:ℤ)+2 ≤ coordinateDistance j + coordinateDistance (j+(n:ℤ)+1) := by
+  have h₁ : -j ≤ coordinateDistance j := le_max_right _ _
+  have h₂ : j+(n:ℤ)+1+1 ≤ coordinateDistance (j+(n:ℤ)+1) := le_max_left _ _
+  omega
+
+lemma sum_coordinateDistance_lower (n : ℕ) (j : ℤ) :
+    (powerCost n : ℤ) ≤ ∑ r ∈ Finset.range n, coordinateDistance (j+(r:ℤ)) := by
+  induction n using Nat.twoStepInduction generalizing j with
+  | zero => simp [powerCost]
+  | one => simpa [powerCost] using coordinateDistance_pos j
+  | more n ih _ =>
+    have hsum : (∑ r ∈ Finset.range (n+2), coordinateDistance (j+(r:ℤ))) =
+        coordinateDistance j + (∑ r ∈ Finset.range n, coordinateDistance ((j+1)+(r:ℤ))) +
+        coordinateDistance (j+(n:ℤ)+1) := by
+      rw [Finset.sum_range_succ, Finset.sum_range_succ']
+      simp only [Nat.cast_add, Nat.cast_one, Nat.cast_zero, add_zero]
+      congr 1
+      · rw [add_comm]
+        congr 1
+        apply Finset.sum_congr rfl
+        intro r hr
+        congr 1
+        ring
+      · congr 1
+        ring
+    rw [hsum, powerCost_add_two]
+    have hmid := ih (j+1)
+    have hend := coordinateDistance_endpoints j n
+    push_cast
+    omega
+
+
+def fiberReindexVector (e : ℤ ≃ ℤ) (v : Fiber) : Fiber :=
+  ⟨fun j => v (e j), by
+    apply memℓp_gen
+    exact ((lp.memℓp v).summable (by norm_num)).comp_injective e.injective⟩
+
+lemma fiberReindex_norm (e : ℤ ≃ ℤ) (v : Fiber) : ‖fiberReindexVector e v‖ = ‖v‖ := by
+  have he : ‖fiberReindexVector e v‖^2 = ‖v‖^2 := by
+    have h₁ := lp.norm_rpow_eq_tsum (by norm_num : (0:ℝ) < (2:ENNReal).toReal) (fiberReindexVector e v)
+    have h₂ := lp.norm_rpow_eq_tsum (by norm_num : (0:ℝ) < (2:ENNReal).toReal) v
+    simp only [ENNReal.toReal_ofNat, Real.rpow_two] at h₁ h₂
+    rw [h₁, h₂]
+    exact e.tsum_eq (fun j => ‖v j‖^2)
+  nlinarith [norm_nonneg (fiberReindexVector e v), norm_nonneg v]
+
+
+def fiberReindex (e : ℤ ≃ ℤ) : Fiber ≃ₗᵢ[ℂ] Fiber where
+  toFun := fiberReindexVector e
+  invFun := fiberReindexVector e.symm
+  left_inv v := by ext j; exact congrArg v (e.apply_symm_apply j)
+  right_inv v := by ext j; exact congrArg v (e.symm_apply_apply j)
+  map_add' v z := by ext j; rfl
+  map_smul' c v := by ext j; rfl
+  norm_map' := fiberReindex_norm e
+
+@[simp] lemma fiberReindex_apply (e : ℤ ≃ ℤ) (v : Fiber) (j : ℤ) :
+    (fiberReindex e v) j = v (e j) := rfl
+
+lemma fiberMultiplier_mem {a : ℤ → ℂ} {C : ℝ} (hC : 0 ≤ C)
+    (ha : ∀ j, ‖a j‖ ≤ C) (v : Fiber) : Memℓp (fun j => a j*v j) 2 := by
+  apply ((lp.memℓp v).const_smul (C:ℂ)).mono'
+  intro j
+  simp only [Pi.smul_apply, norm_smul, Complex.norm_real, Real.norm_of_nonneg hC, norm_mul]
+  exact mul_le_mul_of_nonneg_right (ha j) (norm_nonneg _)
+
+def fiberMultiplierVector (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C) (ha : ∀ j, ‖a j‖ ≤ C)
+    (v : Fiber) : Fiber := ⟨fun j => a j*v j, fiberMultiplier_mem hC ha v⟩
+
+lemma fiberMultiplierVector_bound (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C) (ha : ∀ j, ‖a j‖ ≤ C)
+    (v : Fiber) : ‖fiberMultiplierVector a C hC ha v‖ ≤ C*‖v‖ := by
+  calc
+    _ ≤ ‖(C:ℂ) • v‖ := by
+      apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0)
+      intro j
+      change ‖a j*v j‖ ≤ ‖(C:ℂ)*v j‖
+      rw [norm_mul, norm_mul, Complex.norm_real, Real.norm_of_nonneg hC]
+      exact mul_le_mul_of_nonneg_right (ha j) (norm_nonneg _)
+    _ = C*‖v‖ := by rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg hC]
+
+def fiberMultiplier (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C) (ha : ∀ j, ‖a j‖ ≤ C) :
+    Fiber →L[ℂ] Fiber :=
+  LinearMap.mkContinuous
+    { toFun := fiberMultiplierVector a C hC ha
+      map_add' := by intro v z; ext j; exact mul_add _ _ _
+      map_smul' := by intro c v; ext j; exact mul_left_comm _ _ _ }
+    C (fiberMultiplierVector_bound a C hC ha)
+
+@[simp] lemma fiberMultiplier_apply (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C) (ha : ∀ j, ‖a j‖ ≤ C)
+    (v : Fiber) (j : ℤ) : fiberMultiplier a C hC ha v j = a j*v j := rfl
+
+lemma fiberMultiplier_norm_le (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C) (ha : ∀ j, ‖a j‖ ≤ C) :
+    ‖fiberMultiplier a C hC ha‖ ≤ C :=
+  ContinuousLinearMap.opNorm_le_bound _ hC (fiberMultiplierVector_bound a C hC ha)
+
+
+def fiberWeightedPermutation (e : ℤ ≃ ℤ) (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C)
+    (ha : ∀ j, ‖a j‖ ≤ C) : Fiber →L[ℂ] Fiber :=
+  (fiberReindex e).toLinearIsometry.toContinuousLinearMap.comp (fiberMultiplier a C hC ha)
+
+@[simp] lemma fiberWeightedPermutation_apply (e : ℤ ≃ ℤ) (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C)
+    (ha : ∀ j, ‖a j‖ ≤ C) (v : Fiber) (j : ℤ) :
+    fiberWeightedPermutation e a C hC ha v j = a (e j)*v (e j) := rfl
+
+lemma fiberWeightedPermutation_norm_le (e : ℤ ≃ ℤ) (a : ℤ → ℂ) (C : ℝ) (hC : 0 ≤ C)
+    (ha : ∀ j, ‖a j‖ ≤ C) : ‖fiberWeightedPermutation e a C hC ha‖ ≤ C := by
+  apply ContinuousLinearMap.opNorm_le_bound _ hC
+  intro v
+  change ‖fiberReindex e (fiberMultiplier a C hC ha v)‖ ≤ _
+  rw [(fiberReindex e).norm_map]
+  exact fiberMultiplierVector_bound a C hC ha v
+
+
+
+lemma fiberCoordinates_stronglyMeasurable {X : Type*} [MeasurableSpace X]
+    (f : X → Fiber) (hf : ∀ n : ℤ, Measurable (fun x => f x n)) : StronglyMeasurable f := by
+  apply stronglyMeasurable_of_tendsto (atTop : Filter (Finset ℤ))
+    (f := fun s x => ∑ n ∈ s, lp.single 2 n (f x n))
+  · intro s
+    have h (n : ℤ) : StronglyMeasurable (fun x => (lp.single 2 n (f x n) : Fiber)) :=
+      (lp.singleContinuousLinearMap ℂ (fun _ : ℤ => ℂ) 2 n).continuous.comp_stronglyMeasurable
+        (hf n).stronglyMeasurable
+    convert Finset.stronglyMeasurable_sum s (fun n _ => h n) using 1
+    funext x
+    simp only [Finset.sum_apply]
+  · rw [tendsto_pi_nhds]
+    intro x
+    exact lp.hasSum_single (by norm_num : (2 : ENNReal) ≠ ∞) (f x)
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/FiberTails.lean

@@ -0,0 +1,165 @@
+import OAI.Analysis.BackwardIntertwiners.WeightSeparation
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+abbrev Fiber := lp (fun _ : ℤ => ℂ) 2
+
+
+def coordinateTail (h : ℤ) : Submodule ℂ Fiber where
+  carrier := {v | ∀ j : ℤ, j < h → v j = 0}
+  zero_mem' := by simp
+  add_mem' := by intro v z hv hz j hj; simp [hv j hj, hz j hj]
+  smul_mem' := by intro a v hv j hj; simp [hv j hj]
+
+lemma fiber_exists_coordinate {v : Fiber} (hv : v ≠ 0) : ∃ j : ℤ, v j ≠ 0 := by
+  by_contra! h
+  apply hv
+  ext j
+  exact h j
+
+lemma weighted_shift_pow {w : ℤ → ℝ} (hw : ∀ j, 0 < w j)
+    {T : Fiber →L[ℂ] Fiber}
+    (hT : ∀ v j, T v j = (w j / w (j-1) : ℂ) * v (j-1))
+    (n : ℕ) (v : Fiber) (j : ℤ) :
+    (T^n) v j = (w j / w (j-(n:ℤ)) : ℂ) * v (j-(n:ℤ)) := by
+  have hwC (k : ℤ) : (w k:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt (hw k))
+  induction n generalizing j with
+  | zero => simp [hwC]
+  | succ n ih =>
+    rw [pow_succ']
+    change T ((T^n) v) j = _
+    rw [hT, ih]
+    have hi : j-1-(n:ℤ) = j-((n+1:ℕ):ℤ) := by omega
+    rw [hi]
+    field_simp [hwC]
+
+lemma invariant_pow {T : Fiber →L[ℂ] Fiber} {L : Submodule ℂ Fiber}
+    (hi : ∀ v ∈ L, T v ∈ L) {v : Fiber} (hv : v ∈ L) (n : ℕ) : (T^n) v ∈ L := by
+  induction n with
+  | zero => simpa using hv
+  | succ n ih => simpa only [pow_succ', mul_apply_eq_comp] using hi _ ih
+
+
+
+lemma SupportSeparation.strict_order {w : ℤ → ℝ} (hsep : SupportSeparation w)
+    {b c : ℤ → ℂ} (hbn : ∃ j, b j ≠ 0) (hcn : ∃ j, c j ≠ 0)
+    {B C : ℝ} (hB : 0 < B) (hC : 0 < C)
+    (hb : ∀ j, ‖b j‖ ≤ B*w j) (hc : ∀ j, ‖c j‖*w j ≤ C)
+    (hz : ∀ r : ℕ, (∑' j : ℤ, b j * c (j-r)) = 0)
+    {i j : ℤ} (hbi : b i ≠ 0) (hcj : c j ≠ 0) : i < j := by
+  obtain ⟨t, h, hbt, hch, hbmax, hcmin, hth⟩ :=
+    hsep.of_bounded hbn hcn hB hC hb hc (fun r _ => hz r)
+  have hit : i ≤ t := by by_contra! hh; exact hbi (hbmax i hh)
+  have hhj : h ≤ j := by by_contra! hh; exact hcj (hcmin j hh)
+  have hstrict : t < h := by
+    by_contra! hht
+    have he : t = h := le_antisymm hth hht
+    have hsingle : (∑' k : ℤ, b k*c k) = b t*c h := by
+      rw [tsum_eq_single t, he]
+      intro k hk
+      by_cases hkt : t < k
+      · simp [hbmax k hkt]
+      · rw [hcmin k (by omega), mul_zero]
+    have hzero := hz 0
+    simp only [Nat.cast_zero, sub_zero] at hzero
+    rw [hsingle] at hzero
+    exact (mul_ne_zero hbt hch) hzero
+  omega
+
+
+
+lemma fiber_orthogonal_order {w : ℤ → ℝ} (hw : QuadraticWeights w)
+    {T : Fiber →L[ℂ] Fiber}
+    (hT : ∀ v j, T v j = (w j / w (j-1) : ℂ) * v (j-1))
+    {L : Submodule ℂ Fiber} (hinvariant : ∀ v ∈ L, T v ∈ L)
+    {v z : Fiber} (hv : v ∈ L) (hz : z ∈ L.orthogonal)
+    {i j : ℤ} (hzi : z i ≠ 0) (hvj : v j ≠ 0) : i < j := by
+  let b := fun k : ℤ => star (z k) * (w k:ℂ)
+  let c := fun k : ℤ => v k / (w k:ℂ)
+  have hwC (k : ℤ) : (w k:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt (hw.positive k))
+  have hbi : b i ≠ 0 := mul_ne_zero (by simpa using hzi) (hwC i)
+  have hcj : c j ≠ 0 := div_ne_zero hvj (hwC j)
+  have hb (k : ℤ) : ‖b k‖ ≤ (‖z‖+1)*w k := by
+    dsimp [b]
+    rw [norm_mul, RCLike.norm_conj, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le]
+    apply mul_le_mul_of_nonneg_right _ (hw.positive k).le
+    exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) z k).trans (by linarith)
+  have hc (k : ℤ) : ‖c k‖*w k ≤ ‖v‖+1 := by
+    dsimp [c]
+    rw [norm_div, Complex.norm_real, Real.norm_of_nonneg (hw.positive k).le,
+      div_mul_cancel₀ _ (ne_of_gt (hw.positive k))]
+    exact (lp.norm_apply_le_norm (by norm_num : (2 : ENNReal) ≠ 0) v k).trans (by linarith)
+  have hcor (r : ℕ) : (∑' k : ℤ, b k*c (k-r)) = 0 := by
+    calc (∑' k : ℤ, b k*c (k-r)) = inner ℂ z ((T^r) v) := by
+          rw [lp.inner_eq_tsum]
+          apply tsum_congr
+          intro k
+          rw [RCLike.inner_apply, weighted_shift_pow hw.positive hT]
+          dsimp [b, c]
+          simp only [← Complex.star_def]
+          ring
+      _ = 0 := Submodule.inner_left_of_mem_orthogonal (invariant_pow hinvariant hv r) hz
+  exact (quadratic_support_separation w hw).strict_order ⟨i,hbi⟩ ⟨j,hcj⟩
+    (by positivity : 0 < ‖z‖+1) (by positivity : 0 < ‖v‖+1) hb hc hcor hbi hcj
+
+
+theorem quadratic_fiber_tails (w : ℤ → ℝ) (hw : QuadraticWeights w)
+    (T : Fiber →L[ℂ] Fiber)
+    (hT : ∀ v j, T v j = (w j / w (j-1) : ℂ) * v (j-1))
+    (L : Submodule ℂ Fiber) (hclosed : IsClosed (L : Set Fiber))
+    (hinvariant : ∀ v ∈ L, T v ∈ L) :
+    L = ⊥ ∨ L = ⊤ ∨ ∃ h : ℤ, L = coordinateTail h := by
+  by_cases hbot : L = ⊥
+  · exact Or.inl hbot
+  by_cases htop : L = ⊤
+  · exact Or.inr (Or.inl htop)
+  have hOO : L.orthogonal.orthogonal = L := by
+    rw [Submodule.orthogonal_orthogonal_eq_closure, hclosed.submodule_topologicalClosure_eq]
+  have hnotOrth : L.orthogonal ≠ ⊥ := by
+    intro hh
+    rw [hh, Submodule.bot_orthogonal_eq_top] at hOO
+    exact htop hOO.symm
+  obtain ⟨z, hz, hzne⟩ := (Submodule.ne_bot_iff L.orthogonal).mp hnotOrth
+  obtain ⟨i, hzi⟩ := fiber_exists_coordinate hzne
+  obtain ⟨v, hv, hvne⟩ := (Submodule.ne_bot_iff L).mp hbot
+  obtain ⟨j, hvj⟩ := fiber_exists_coordinate hvne
+  let P := fun k : ℤ => ∃ c : Fiber, c ∈ L ∧ c k ≠ 0
+  have hPnonempty : ∃ k, P k := ⟨j, v, hv, hvj⟩
+  have hPbound : ∃ a : ℤ, ∀ k : ℤ, P k → a ≤ k := by
+    refine ⟨i+1, ?_⟩
+    rintro k ⟨c, hc, hck⟩
+    have hh := fiber_orthogonal_order hw hT hinvariant hc hz hzi hck
+    omega
+  obtain ⟨h, hhP, hhmin⟩ := Int.exists_least_of_bdd hPbound hPnonempty
+  obtain ⟨v₀, hv₀, hv₀h⟩ := hhP
+  refine Or.inr (Or.inr ⟨h, le_antisymm ?_ ?_⟩)
+  · intro c hc k hk
+    by_contra hck
+    have hh := hhmin k ⟨c, hc, hck⟩
+    omega
+  · intro c hc
+    rw [← hOO]
+    apply (Submodule.mem_orthogonal _ c).mpr
+    intro u hu
+    rw [lp.inner_eq_tsum]
+    apply Eq.trans (tsum_congr (g := fun _ : ℤ => (0:ℂ)) ?_) tsum_zero
+    intro k
+    rw [RCLike.inner_apply]
+    by_cases hkh : k < h
+    · rw [hc k hkh, zero_mul]
+    · have huk : u k = 0 := by
+        by_contra hne
+        have hh := fiber_orthogonal_order hw hT hinvariant hv₀ hu hne hv₀h
+        exact hkh hh
+      simp [huk]
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/GlobalOperators.lean

@@ -0,0 +1,473 @@
+import OAI.Analysis.BackwardIntertwiners.BackwardWeights
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+section Fields
+variable {X : Type*} [MeasurableSpace X] {μ : Measure X}
+
+lemma weightedPermutation_stronglyMeasurable (e : ℤ ≃ ℤ) (a : X → ℤ → ℂ)
+    (C : ℝ) (hC : 0 ≤ C) (ha : ∀ x j, ‖a x j‖ ≤ C)
+    (hm : ∀ j, Measurable (fun x => a x j))
+    {f : X → Fiber} (hf : StronglyMeasurable f) :
+    StronglyMeasurable (fun x => fiberWeightedPermutation e (a x) C hC (ha x) (f x)) := by
+  apply fiberCoordinates_stronglyMeasurable
+  intro j
+  exact (hm (e j)).mul (((lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 (e j)).continuous.comp_stronglyMeasurable hf).measurable)
+
+lemma weightedPermutation_aestronglyMeasurable (e : ℤ ≃ ℤ) (a : X → ℤ → ℂ)
+    (C : ℝ) (hC : 0 ≤ C) (ha : ∀ x j, ‖a x j‖ ≤ C)
+    (hm : ∀ j, Measurable (fun x => a x j))
+    {f : X → Fiber} (hf : AEStronglyMeasurable f μ) :
+    AEStronglyMeasurable (fun x => fiberWeightedPermutation e (a x) C hC (ha x) (f x)) μ := by
+  apply (weightedPermutation_stronglyMeasurable e a C hC ha hm hf.stronglyMeasurable_mk).aestronglyMeasurable.congr
+  filter_upwards [hf.ae_eq_mk] with x hx
+  rw [hx]
+
+
+def scalarMultiplier (g : Lp ℂ ∞ μ) : Lp Fiber 2 μ →L[ℂ] Lp Fiber 2 μ :=
+  LinearMap.mkContinuous
+    { toFun := fun f => g • f
+      map_add' := Lp.add_smul g
+      map_smul' := fun c f => (Lp.smul_comm c g f).symm }
+    ‖g‖ (Lp.norm_smul_le g)
+
+def fieldVector (A : X → Fiber →L[ℂ] Fiber) (C : ℝ)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ)
+    (f : Lp Fiber 2 μ) : Lp Fiber 2 μ :=
+  ((Lp.memLp f).of_le_mul (hm f (Lp.aestronglyMeasurable f))
+    (Filter.Eventually.of_forall fun x =>
+      (A x).le_opNorm (f x) |>.trans (mul_le_mul_of_nonneg_right (hA x) (norm_nonneg _)))).toLp _
+
+lemma fieldVector_ae (A : X → Fiber →L[ℂ] Fiber) (C : ℝ)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ)
+    (f : Lp Fiber 2 μ) : fieldVector A C hA hm f =ᵐ[μ] fun x => A x (f x) :=
+  MemLp.coeFn_toLp _
+
+lemma fieldVector_norm (A : X → Fiber →L[ℂ] Fiber) (C : ℝ) (hC : 0 ≤ C)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ)
+    (f : Lp Fiber 2 μ) : ‖fieldVector A C hA hm f‖ ≤ C*‖f‖ := by
+  calc
+    _ ≤ ‖(C:ℂ) • f‖ := by
+      apply Lp.norm_le_norm_of_ae_le
+      filter_upwards [fieldVector_ae A C hA hm f, Lp.coeFn_smul (C:ℂ) f] with x hx hs
+      rw [hx, hs, Pi.smul_apply, norm_smul, Complex.norm_real, Real.norm_of_nonneg hC]
+      exact (A x).le_opNorm (f x) |>.trans (mul_le_mul_of_nonneg_right (hA x) (norm_nonneg _))
+    _ = C*‖f‖ := by rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg hC]
+
+def fieldOperator (A : X → Fiber →L[ℂ] Fiber) (C : ℝ) (hC : 0 ≤ C)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ) :
+    Lp Fiber 2 μ →L[ℂ] Lp Fiber 2 μ :=
+  LinearMap.mkContinuous
+    { toFun := fieldVector A C hA hm
+      map_add' := by
+        intro f g
+        apply Lp.ext
+        filter_upwards [fieldVector_ae A C hA hm (f+g), fieldVector_ae A C hA hm f,
+          fieldVector_ae A C hA hm g, Lp.coeFn_add f g,
+          Lp.coeFn_add (fieldVector A C hA hm f) (fieldVector A C hA hm g)] with x h₁ h₂ h₃ h₄ h₅
+        simp only [h₁,h₂,h₃,h₄,h₅,Pi.add_apply,map_add]
+      map_smul' := by
+        intro c f
+        apply Lp.ext
+        filter_upwards [fieldVector_ae A C hA hm (c • f), fieldVector_ae A C hA hm f,
+          Lp.coeFn_smul c f, Lp.coeFn_smul c (fieldVector A C hA hm f)] with x h₁ h₂ h₃ h₄
+        simp only [RingHom.id_apply, h₁,h₂,h₃,h₄,Pi.smul_apply,map_smul] }
+    C (fieldVector_norm A C hC hA hm)
+
+lemma fieldOperator_ae (A : X → Fiber →L[ℂ] Fiber) (C : ℝ) (hC : 0 ≤ C)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ)
+    (f : Lp Fiber 2 μ) : fieldOperator A C hC hA hm f =ᵐ[μ] fun x => A x (f x) :=
+  fieldVector_ae A C hA hm f
+
+lemma fieldOperator_norm (A : X → Fiber →L[ℂ] Fiber) (C : ℝ) (hC : 0 ≤ C)
+    (hA : ∀ x, ‖A x‖ ≤ C)
+    (hm : ∀ f : X → Fiber, AEStronglyMeasurable f μ → AEStronglyMeasurable (fun x => A x (f x)) μ) :
+    ‖fieldOperator A C hC hA hm‖ ≤ C :=
+  ContinuousLinearMap.opNorm_le_bound _ hC (fieldVector_norm A C hC hA hm)
+
+lemma scalarMultiplier_ae (g : Lp ℂ ∞ μ) (f : Lp Fiber 2 μ) :
+    scalarMultiplier g f =ᵐ[μ] fun x => g x • f x := Lp.coeFn_lpSMul g f
+lemma scalarMultiplier_norm_le (g : Lp ℂ ∞ μ) : ‖scalarMultiplier (μ := μ) g‖ ≤ ‖g‖ :=
+  ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg g) (Lp.norm_smul_le g)
+end Fields
+
+abbrev GlobalHilbert := Lp Fiber 2 baseMeasure
+
+def OperatorInvariant {H : Type*} [NormedAddCommGroup H] [NormedSpace ℂ H]
+    (L : Submodule ℂ H) (T : H →L[ℂ] H) : Prop := ∀ v ∈ L, T v ∈ L
+
+def generatedAlgebra (S V : GlobalHilbert →L[ℂ] GlobalHilbert) :
+    Subalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) :=
+  Algebra.adjoin ℂ ({S,V} ∪ Set.range (scalarMultiplier (μ := baseMeasure)))
+
+def AlgebraTransitive (A : Subalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert)) : Prop :=
+  ∀ L : Submodule ℂ GlobalHilbert, IsClosed (L : Set GlobalHilbert) →
+    (∀ T ∈ A, OperatorInvariant L T) → L = ⊥ ∨ L = ⊤
+
+
+structure DirectModelData where
+  Sx : Base → Fiber →L[ℂ] Fiber
+  S : GlobalHilbert →L[ℂ] GlobalHilbert
+  b : Base → ℤ → ℝ
+  Vx : Base → Fiber →L[ℂ] Fiber
+  V : GlobalHilbert →L[ℂ] GlobalHilbert
+
+
+
+
+structure DirectModelProperties (D : DirectModelData) : Prop where
+  beta_measurable : ∀ j, Measurable (fun x => explicitBeta x j)
+  beta_positive : ∀ x j, 0 < explicitBeta x j
+  forward_coordinates : ∀ x v j, D.Sx x v j = (explicitBeta x (j-1):ℂ)*v (j-1)
+  forward_field : ∀ f, D.S f =ᵐ[baseMeasure] fun x => D.Sx x (f x)
+  fiber_lattice : ∀ x (L : Submodule ℂ Fiber),
+    (IsClosed (L : Set Fiber) ∧ OperatorInvariant L (D.Sx x)) ↔
+      L = ⊥ ∨ L = ⊤ ∨ ∃ h : ℤ, L = coordinateTail h
+  S_nonzero : D.S ≠ 0
+  S_norm : ‖D.S‖ = Real.exp (-10)
+  power_bound : ∀ n : ℕ, 1 ≤ n → ‖D.S^n‖ ≤ Real.exp (-10*(((n+1)^2/4:ℕ):ℝ))
+  V_contraction : ‖D.V‖ ≤ 1
+  commute : D.S * D.V = D.V * D.S
+  backward_measurable : ∀ j, Measurable (fun x => D.b x j)
+  backward_bounds : ∀ x j, 0 ≤ D.b x j ∧ D.b x j ≤ 1
+  backward_coordinates : ∀ x v j, D.Vx x v j = (D.b x (j+1):ℂ)*v (j+1)
+  backward_field : ∀ f, ∀ᵐ x ∂baseMeasure, D.V f (odometer x) = D.Vx x (f x)
+  common_conull : ∃ Xstar : Set Base, MeasurableSet Xstar ∧ baseMeasure Xstarᶜ = 0 ∧
+    odometer ⁻¹' Xstar = Xstar ∧ ∀ x ∈ Xstar,
+      (∀ j, 0 < D.b x j) ∧
+      (∀ h : ℤ, ((coordinateTail h).map (D.Vx x).toLinearMap).topologicalClosure = coordinateTail (h-1)) ∧
+      DenseRange (D.Vx x)
+  transitive : AlgebraTransitive (generatedAlgebra D.S D.V)
+
+
+
+def forwardFiber (x : Base) : Fiber →L[ℂ] Fiber :=
+  fiberWeightedPermutation (Equiv.subRight 1) (fun j => (explicitBeta x j:ℂ))
+    (Real.exp (-10)) (Real.exp_pos _).le
+    (fun j => by simpa only [Complex.norm_real, Real.norm_of_nonneg (explicitBeta_pos x j).le] using explicitBeta_le x j)
+def backwardFiber (x : Base) : Fiber →L[ℂ] Fiber :=
+  fiberWeightedPermutation (Equiv.addRight 1) (fun j => (backwardCoeff x j:ℂ)) 1 (by norm_num)
+    (fun j => by simpa only [Complex.norm_real, Real.norm_of_nonneg (backwardCoeff_bounds x j).1] using (backwardCoeff_bounds x j).2)
+@[simp] lemma forwardFiber_apply (x : Base) (v : Fiber) (j : ℤ) :
+    forwardFiber x v j = (explicitBeta x (j-1):ℂ) * v (j-1) := rfl
+@[simp] lemma backwardFiber_apply (x : Base) (v : Fiber) (j : ℤ) :
+    backwardFiber x v j = (backwardCoeff x (j+1):ℂ) * v (j+1) := rfl
+lemma forwardFiber_norm_le (x : Base) : ‖forwardFiber x‖ ≤ Real.exp (-10) :=
+  fiberWeightedPermutation_norm_le _ _ _ _ _
+lemma backwardFiber_norm_le (x : Base) : ‖backwardFiber x‖ ≤ 1 :=
+  fiberWeightedPermutation_norm_le _ _ _ _ _
+lemma forwardFiber_single (x : Base) (j : ℤ) (c : ℂ) :
+    forwardFiber x (lp.single 2 j c) = lp.single 2 (j+1) ((explicitBeta x j:ℂ)*c) := by
+  ext k
+  rw [forwardFiber_apply]
+  by_cases hk : k = j+1
+  · subst k
+    simp
+  · have hj : k-1 ≠ j := by omega
+    simp only [lp.single_apply_ne _ _ _ hk, lp.single_apply_ne _ _ _ hj, mul_zero]
+lemma backwardFiber_single (x : Base) (j : ℤ) (c : ℂ) :
+    backwardFiber x (lp.single 2 j c) = lp.single 2 (j-1) ((backwardCoeff x j:ℂ)*c) := by
+  ext k
+  rw [backwardFiber_apply]
+  by_cases hk : k = j-1
+  · subst k
+    simp
+  · have hj : k+1 ≠ j := by omega
+    simp only [lp.single_apply_ne _ _ _ hk, lp.single_apply_ne _ _ _ hj, mul_zero]
+lemma forwardFiber_norm (x : Base) : ‖forwardFiber x‖ = Real.exp (-10) := by
+  apply le_antisymm (forwardFiber_norm_le x)
+  have hh := (forwardFiber x).le_opNorm (lp.single 2 0 (1:ℂ))
+  rw [forwardFiber_single, explicitBeta_zero, mul_one, lp.norm_single (by norm_num : (0:ENNReal)<2),
+    lp.norm_single (by norm_num : (0:ENNReal)<2), norm_one, mul_one,
+    Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le] at hh
+  exact hh
+
+lemma backwardFiber_intertwines (x : Base) :
+    forwardFiber (odometer x) * backwardFiber x = backwardFiber x * forwardFiber x := by
+  ext v j
+  simp only [mul_apply_eq_comp, forwardFiber_apply, backwardFiber_apply,
+    sub_add_cancel, add_sub_cancel_right]
+  have hc := congrArg (fun r : ℝ => (r:ℂ)) (backwardCoeff_recurrence x j)
+  push_cast at hc
+  linear_combination -hc * v j
+
+lemma coordinateTail_isClosed (h : ℤ) : IsClosed (coordinateTail h : Set Fiber) := by
+  have he : (coordinateTail h : Set Fiber) = ⋂ j : ℤ, ⋂ _ : j < h, {v : Fiber | v j = 0} := by
+    ext v
+    change (∀ j : ℤ, j < h → v j = 0) ↔ _
+    simp only [Set.mem_iInter, Set.mem_ofPred_eq]
+  rw [he]
+  exact isClosed_iInter fun j => isClosed_iInter fun _ =>
+    isClosed_eq (lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).continuous continuous_const
+lemma forwardFiber_tail (x : Base) (h : ℤ) {v : Fiber} (hv : v ∈ coordinateTail h) :
+    forwardFiber x v ∈ coordinateTail h := by
+  intro j hj
+  rw [forwardFiber_apply, hv _ (by omega), mul_zero]
+lemma backwardFiber_tail (x : Base) (h : ℤ) {v : Fiber} (hv : v ∈ coordinateTail h) :
+    backwardFiber x v ∈ coordinateTail (h-1) := by
+  intro j hj
+  rw [backwardFiber_apply, hv _ (by omega), mul_zero]
+lemma single_mem_coordinateTail {h j : ℤ} (hj : h ≤ j) (c : ℂ) :
+    (lp.single 2 j c : Fiber) ∈ coordinateTail h := by
+  intro k hk
+  exact lp.single_apply_ne _ _ _ (by omega)
+
+lemma backwardFiber_tail_closure {x : Base} (hx : x ∈ goodBase) (h : ℤ) :
+    ((coordinateTail h).map (backwardFiber x).toLinearMap).topologicalClosure = coordinateTail (h-1) := by
+  apply le_antisymm
+  · apply Submodule.topologicalClosure_minimal _ ?_ (coordinateTail_isClosed (h-1))
+    rintro _ ⟨v,hv,rfl⟩
+    exact backwardFiber_tail x h hv
+  · intro v hv
+    let P := ((coordinateTail h).map (backwardFiber x).toLinearMap).topologicalClosure
+    have hP : IsClosed (P : Set Fiber) := Submodule.isClosed_topologicalClosure _
+    apply hP.mem_of_tendsto (lp.hasSum_single (by norm_num : (2:ENNReal) ≠ ∞) v)
+    apply Filter.Eventually.of_forall
+    intro s
+    apply P.sum_mem
+    intro j _
+    by_cases hj : j < h-1
+    · rw [hv j hj, lp.single_zero]
+      exact P.zero_mem
+    · apply (Submodule.le_topologicalClosure ((coordinateTail h).map (backwardFiber x).toLinearMap))
+      refine ⟨lp.single 2 (j+1) (v j / (backwardCoeff x (j+1):ℂ)),
+        single_mem_coordinateTail (by omega) _, ?_⟩
+      change backwardFiber x (_) = _
+      rw [backwardFiber_single, add_sub_cancel_right, mul_div_cancel₀]
+      exact_mod_cast ne_of_gt (backwardCoeff_pos hx (j+1))
+
+lemma backwardFiber_denseRange {x : Base} (hx : x ∈ goodBase) : DenseRange (backwardFiber x) := by
+  intro v
+  have hcl : IsClosed (closure (Set.range (backwardFiber x))) := isClosed_closure
+  apply hcl.mem_of_tendsto (lp.hasSum_single (by norm_num : (2:ENNReal) ≠ ∞) v)
+  apply Filter.Eventually.of_forall
+  intro s
+  apply subset_closure
+  refine ⟨∑ j ∈ s, lp.single 2 (j+1) (v j / (backwardCoeff x (j+1):ℂ)), ?_⟩
+  rw [map_sum]
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [backwardFiber_single, add_sub_cancel_right, mul_div_cancel₀]
+  exact_mod_cast ne_of_gt (backwardCoeff_pos hx (j+1))
+
+lemma explicitExponent_distance (x : Base) (j : ℤ) :
+    10*(coordinateDistance j:ℝ) ≤ explicitExponent x j := by
+  cases j with
+  | ofNat n =>
+    have hd : coordinateDistance (n:ℤ) = (n:ℤ)+1 := by
+      unfold coordinateDistance
+      omega
+    change 10*(coordinateDistance (n:ℤ):ℝ) ≤ halfExponent (plusResidue x) n
+    rw [hd]
+    simpa only [Int.cast_add, Int.cast_one, Int.cast_natCast] using halfExponent_lower (plusResidue x) n
+  | negSucc n =>
+    have hd : coordinateDistance (Int.negSucc n) = (n:ℤ)+1 := by
+      unfold coordinateDistance
+      omega
+    rw [hd]
+    change _ ≤ halfExponent (minusResidue x) n
+    simpa only [Int.cast_add, Int.cast_one, Int.cast_natCast] using halfExponent_lower (minusResidue x) n
+
+lemma interval_exponent_lower (x : Base) (n : ℕ) (j : ℤ) :
+    10*(powerCost n:ℝ) ≤ ∑ r ∈ Finset.range n, explicitExponent x (j+(r:ℤ)) := by
+  have hc : (powerCost n:ℝ) ≤ ∑ r ∈ Finset.range n, (coordinateDistance (j+(r:ℤ)):ℝ) := by
+    exact_mod_cast sum_coordinateDistance_lower n j
+  calc
+    _ ≤ 10*(∑ r ∈ Finset.range n, (coordinateDistance (j+(r:ℤ)):ℝ)) := by linarith
+    _ = ∑ r ∈ Finset.range n, 10*(coordinateDistance (j+(r:ℤ)):ℝ) := by rw [Finset.mul_sum]
+    _ ≤ _ := Finset.sum_le_sum fun _ _ => explicitExponent_distance x _
+
+lemma forwardFiber_power_input (x : Base) (n : ℕ) (v : Fiber) (j : ℤ) :
+    (forwardFiber x ^ n) v (j+(n:ℤ)) =
+      (Real.exp (-(∑ r ∈ Finset.range n, explicitExponent x (j+(r:ℤ)))):ℂ)*v j := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [pow_succ', mul_apply_eq_comp, forwardFiber_apply]
+    have hi : j+((n+1:ℕ):ℤ)-1 = j+(n:ℤ) := by omega
+    rw [hi, ih, Finset.sum_range_succ]
+    change (Real.exp (-explicitExponent x (j+(n:ℤ))):ℂ)*
+      ((Real.exp (-(∑ r ∈ Finset.range n, explicitExponent x (j+(r:ℤ)))):ℂ)*v j) = _
+    rw [← mul_assoc, ← Complex.ofReal_mul, ← Real.exp_add]
+    rw [neg_add_rev]
+
+lemma forwardFiber_power_norm (x : Base) (n : ℕ) :
+    ‖forwardFiber x ^ n‖ ≤ Real.exp (-10*(powerCost n:ℝ)) := by
+  let C := Real.exp (-10*(powerCost n:ℝ))
+  have hC : 0 ≤ C := (Real.exp_pos _).le
+  apply ContinuousLinearMap.opNorm_le_bound _ (Real.exp_pos _).le
+  intro v
+  calc
+    _ ≤ ‖(C:ℂ) • fiberReindex (Equiv.subRight (n:ℤ)) v‖ := by
+      apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0)
+      intro j
+      have hi : j = (j-(n:ℤ))+(n:ℤ) := by omega
+      conv_lhs => rw [hi, forwardFiber_power_input]
+      simp only [lp.coeFn_smul, Pi.smul_apply, norm_smul, fiberReindex_apply, Equiv.subRight_apply,
+        norm_mul, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le, Real.norm_of_nonneg hC]
+      apply mul_le_mul_of_nonneg_right _ (norm_nonneg _)
+      apply Real.exp_le_exp.mpr
+      simpa only [neg_mul] using neg_le_neg (interval_exponent_lower x n (j-(n:ℤ)))
+    _ = C*‖v‖ := by
+      rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le, (fiberReindex _).norm_map]
+
+
+lemma forwardFiber_aestronglyMeasurable (f : Base → Fiber) (hf : AEStronglyMeasurable f baseMeasure) :
+    AEStronglyMeasurable (fun x => forwardFiber x (f x)) baseMeasure := by
+  apply weightedPermutation_aestronglyMeasurable
+  · exact fun j => Complex.measurable_ofReal.comp (measurable_explicitBeta j)
+  · exact hf
+lemma backwardFiber_aestronglyMeasurable (f : Base → Fiber) (hf : AEStronglyMeasurable f baseMeasure) :
+    AEStronglyMeasurable (fun x => backwardFiber x (f x)) baseMeasure := by
+  apply weightedPermutation_aestronglyMeasurable
+  · exact fun j => Complex.measurable_ofReal.comp (measurable_backwardCoeff j)
+  · exact hf
+
+def forwardOperator : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  fieldOperator forwardFiber (Real.exp (-10)) (Real.exp_pos _).le
+    forwardFiber_norm_le forwardFiber_aestronglyMeasurable
+lemma forwardOperator_ae (f : GlobalHilbert) :
+    forwardOperator f =ᵐ[baseMeasure] fun x => forwardFiber x (f x) :=
+  fieldOperator_ae _ _ _ _ _ f
+lemma forwardOperator_norm_le : ‖forwardOperator‖ ≤ Real.exp (-10) :=
+  fieldOperator_norm _ _ _ _ _
+
+def inverseOdometer (x : Base) : Base := (show PadicInt 2 from x)-1
+@[simp] lemma inverseOdometer_odometer (x : Base) : inverseOdometer (odometer x) = x := by
+  change ((show PadicInt 2 from x)+1)-1 = _
+  exact add_sub_cancel_right _ _
+@[simp] lemma odometer_inverseOdometer (x : Base) : odometer (inverseOdometer x) = x := by
+  change ((show PadicInt 2 from x)-1)+1 = _
+  exact sub_add_cancel _ _
+lemma inverseOdometer_preserving : MeasurePreserving inverseOdometer baseMeasure baseMeasure := by
+  have hh := measurePreserving_completion (α := PadicInt 2) (measurePreserving_add_right baseHaar (-1))
+  have he : inverseOdometer = (show Base → Base from fun x : PadicInt 2 => x + (-1)) := by
+    funext x
+    exact @sub_eq_add_neg (PadicInt 2) _ (show PadicInt 2 from x) 1
+  rw [he]
+  exact hh
+
+def odometerMeasurableEquiv : Base ≃ᵐ Base where
+  toFun := odometer
+  invFun := inverseOdometer
+  left_inv := inverseOdometer_odometer
+  right_inv := odometer_inverseOdometer
+  measurable_toFun := odometer_ergodic.measurable
+  measurable_invFun := inverseOdometer_preserving.measurable
+
+def backwardFieldOperator : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  fieldOperator backwardFiber 1 (by norm_num) backwardFiber_norm_le backwardFiber_aestronglyMeasurable
+
+def backwardOperator : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  (Lp.compMeasurePreservingₗᵢ ℂ inverseOdometer inverseOdometer_preserving).toContinuousLinearMap.comp backwardFieldOperator
+
+lemma backwardOperator_ae_inverse (f : GlobalHilbert) :
+    backwardOperator f =ᵐ[baseMeasure] fun x => backwardFiber (inverseOdometer x) (f (inverseOdometer x)) := by
+  have h₁ := Lp.coeFn_compMeasurePreserving (backwardFieldOperator f) inverseOdometer_preserving
+  have h₂ := (fieldOperator_ae backwardFiber 1 (by norm_num) backwardFiber_norm_le
+    backwardFiber_aestronglyMeasurable f).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae
+  exact h₁.trans h₂
+
+lemma backwardOperator_ae (f : GlobalHilbert) :
+    ∀ᵐ x ∂baseMeasure, backwardOperator f (odometer x) = backwardFiber x (f x) := by
+  filter_upwards [(backwardOperator_ae_inverse f).comp_tendsto
+    odometer_ergodic.quasiMeasurePreserving.tendsto_ae] with x hx
+  simpa only [Function.comp_def,inverseOdometer_odometer] using hx
+
+lemma backwardOperator_norm : ‖backwardOperator‖ ≤ 1 := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (by norm_num)
+  intro f
+  change ‖Lp.compMeasurePreserving inverseOdometer inverseOdometer_preserving (backwardFieldOperator f)‖ ≤ _
+  rw [Lp.norm_compMeasurePreserving]
+  exact fieldVector_norm backwardFiber 1 (by norm_num) backwardFiber_norm_le backwardFiber_aestronglyMeasurable f
+
+lemma forward_backward_commute : forwardOperator * backwardOperator = backwardOperator * forwardOperator := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [forwardOperator_ae (backwardOperator f), backwardOperator_ae_inverse f,
+    backwardOperator_ae_inverse (forwardOperator f),
+    (forwardOperator_ae f).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae] with x h₁ h₂ h₃ h₄
+  change forwardOperator (backwardOperator f) x = backwardOperator (forwardOperator f) x
+  rw [h₁,h₂,h₃]
+
+  dsimp only [Function.comp_def] at h₄
+  rw [h₄]
+  have hh := congrArg (fun A : Fiber →L[ℂ] Fiber => A (f (inverseOdometer x))) (backwardFiber_intertwines (inverseOdometer x))
+  simpa only [mul_apply_eq_comp, odometer_inverseOdometer] using hh
+
+lemma forward_scalar_commute (g : Lp ℂ ∞ baseMeasure) :
+    forwardOperator * scalarMultiplier g = scalarMultiplier g * forwardOperator := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [forwardOperator_ae (scalarMultiplier g f), scalarMultiplier_ae g f,
+    scalarMultiplier_ae g (forwardOperator f), forwardOperator_ae f] with x h₁ h₂ h₃ h₄
+  change forwardOperator (scalarMultiplier g f) x = scalarMultiplier g (forwardOperator f) x
+  simp only [h₁,h₂,h₃,h₄,map_smul]
+
+def constantBasis (j : ℤ) : GlobalHilbert := Lp.const 2 baseMeasure (lp.single 2 j (1:ℂ))
+lemma constantBasis_norm (j : ℤ) : ‖constantBasis j‖ = 1 := by
+  rw [constantBasis, Lp.norm_const 2 baseMeasure _ (by norm_num), lp.norm_single (by norm_num : (0:ENNReal)<2)]
+  simp
+lemma constantBasis_ae (j : ℤ) : constantBasis j =ᵐ[baseMeasure] fun _ => lp.single 2 j (1:ℂ) :=
+  Lp.coeFn_const _ _ _
+lemma forwardOperator_constantBasis_zero :
+    forwardOperator (constantBasis 0) = (Real.exp (-10):ℂ) • constantBasis 1 := by
+  apply Lp.ext
+  filter_upwards [forwardOperator_ae (constantBasis 0), constantBasis_ae 0, constantBasis_ae 1,
+    Lp.coeFn_smul (Real.exp (-10):ℂ) (constantBasis 1)] with x h₁ h₂ h₃ h₄
+  rw [h₁,h₂,h₄,Pi.smul_apply,h₃,forwardFiber_single,explicitBeta_zero,mul_one]
+  rw [← lp.single_smul]
+  simp
+lemma forwardOperator_norm : ‖forwardOperator‖ = Real.exp (-10) := by
+  apply le_antisymm forwardOperator_norm_le
+  have h := forwardOperator.le_opNorm (constantBasis 0)
+  rw [forwardOperator_constantBasis_zero, norm_smul, constantBasis_norm, constantBasis_norm,
+    mul_one, mul_one, Complex.norm_real, Real.norm_of_nonneg (Real.exp_pos _).le] at h
+  exact h
+lemma forwardOperator_ne_zero : forwardOperator ≠ 0 := by
+  intro h
+  have hh := forwardOperator_norm
+  rw [h, norm_zero] at hh
+  exact (Real.exp_ne_zero (-10)) hh.symm
+
+lemma forwardOperator_power_ae (n : ℕ) (f : GlobalHilbert) :
+    (forwardOperator^n) f =ᵐ[baseMeasure] fun x => (forwardFiber x ^ n) (f x) := by
+  induction n with
+  | zero => filter_upwards [] with x; rfl
+  | succ n ih =>
+    rw [pow_succ', mul_apply_eq_comp]
+    filter_upwards [forwardOperator_ae ((forwardOperator^n) f), ih] with x h₁ h₂
+    simp only [h₁,h₂,pow_succ',mul_apply_eq_comp]
+lemma forwardOperator_power_norm (n : ℕ) :
+    ‖forwardOperator^n‖ ≤ Real.exp (-10*(powerCost n:ℝ)) := by
+  let C := Real.exp (-10*(powerCost n:ℝ))
+  have hC : 0 ≤ C := (Real.exp_pos _).le
+  apply ContinuousLinearMap.opNorm_le_bound _ hC
+  intro f
+  calc
+    _ ≤ ‖(C:ℂ) • f‖ := by
+      apply Lp.norm_le_norm_of_ae_le
+      filter_upwards [forwardOperator_power_ae n f, Lp.coeFn_smul (C:ℂ) f] with x h₁ h₂
+      rw [h₁,h₂,Pi.smul_apply,norm_smul,Complex.norm_real,Real.norm_of_nonneg hC]
+      exact (forwardFiber x ^ n).le_opNorm (f x) |>.trans
+        (mul_le_mul_of_nonneg_right (forwardFiber_power_norm x n) (norm_nonneg _))
+    _ = C*‖f‖ := by rw [norm_smul,Complex.norm_real,Real.norm_of_nonneg hC]
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/HaarBase.lean

@@ -0,0 +1,195 @@
+import OAI.Analysis.BackwardIntertwiners.ExplicitWeights
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+instance padicBorel : MeasurableSpace (PadicInt 2) := borel _
+instance padicBorelSpace : BorelSpace (PadicInt 2) := ⟨rfl⟩
+
+def baseHaar : Measure (PadicInt 2) := Measure.addHaarMeasure ⊤
+instance baseHaar_probability : IsProbabilityMeasure baseHaar := by
+  constructor
+  exact Measure.addHaarMeasure_self
+instance baseHaar_regular : baseHaar.Regular := inferInstanceAs ((Measure.addHaarMeasure ⊤).Regular)
+instance baseHaar_addHaar : baseHaar.IsAddHaarMeasure :=
+  inferInstanceAs ((Measure.addHaarMeasure ⊤).IsAddHaarMeasure)
+
+def odometerBorel (x : PadicInt 2) : PadicInt 2 := x + 1
+lemma odometerBorel_ergodic : Ergodic odometerBorel baseHaar := by
+  have hd : DenseRange (fun n : ℤ => n • (1 : PadicInt 2)) := by
+    simpa only [zsmul_one] using (PadicInt.denseRange_intCast (p := 2))
+  have he : (fun x : PadicInt 2 => 1+x) = odometerBorel := funext fun x => add_comm 1 x
+  rw [← he]
+  exact ergodic_add_left_of_denseRange_zsmul hd baseHaar
+
+lemma continuous_twoResidue (m : ℕ) : Continuous (PadicInt.toZModPow (p := 2) m) := by
+  apply IsLocallyConstant.continuous
+  rw [IsLocallyConstant.iff_eventually_eq]
+  intro x
+  have hp : 0 < (2:ℝ)^(-(m:ℤ)) := zpow_pos (by norm_num) _
+  filter_upwards [Metric.ball_mem_nhds x hp] with y hy
+  have hnorm : ‖y-x‖ ≤ (2:ℝ)^(-(m:ℤ)) := (by simpa [dist_eq_norm] using hy : ‖y-x‖ < _).le
+  have hmem := (PadicInt.norm_le_pow_iff_mem_span_pow (y-x) m).mp hnorm
+  rw [← PadicInt.ker_toZModPow, RingHom.mem_ker, map_sub, sub_eq_zero] at hmem
+  exact hmem
+
+def twoResidue (m : ℕ) (x : PadicInt 2) : ℕ := (PadicInt.toZModPow m x).val
+lemma twoResidue_lt (m : ℕ) (x : PadicInt 2) : twoResidue m x < 2^m := ZMod.val_lt _
+lemma measurable_twoResidue (m : ℕ) : Measurable (twoResidue m) :=
+  (measurable_of_countable (f := ZMod.val)).comp (continuous_twoResidue m).measurable
+
+lemma baseHaar_singleton_eq (x y : PadicInt 2) : baseHaar {x} = baseHaar {y} := by
+  have he : (fun z : PadicInt 2 => (y-x)+z) ⁻¹' {y} = {x} := by
+    ext z
+    change (y-x)+z = y ↔ z = x
+    constructor
+    · intro h
+      have hh := congrArg (fun v : PadicInt 2 => v-(y-x)) h
+      abel_nf at hh
+      exact hh
+    · rintro rfl
+      abel
+  rw [← he]
+  exact measure_preimage_add baseHaar (y-x) {y}
+
+instance baseHaar_nullSingleton : NullSingletonClass baseHaar := by
+  constructor
+  intro x
+  by_contra hx
+  have hd : Pairwise (fun i j : ℕ => Disjoint ({(i:PadicInt 2)} : Set (PadicInt 2)) {(j:PadicInt 2)}) := by
+    intro i j hij
+    apply Set.disjoint_singleton.mpr
+    exact_mod_cast hij
+  have hs : (∑' _n : ℕ, baseHaar {x}) ≤ 1 := calc
+    _ = ∑' n : ℕ, baseHaar {(n:PadicInt 2)} := tsum_congr fun n => baseHaar_singleton_eq _ _
+    _ = baseHaar (⋃ n : ℕ, {(n:PadicInt 2)}) := (measure_iUnion hd (fun _ => measurableSet_singleton _)).symm
+    _ ≤ 1 := by simpa using (measure_mono (Set.subset_univ _) : baseHaar _ ≤ baseHaar Set.univ)
+  rw [ENNReal.tsum_const_eq_top_of_ne_zero hx] at hs
+  exact (not_le_of_gt ENNReal.one_lt_top) hs
+
+
+
+lemma measurePreserving_completion {α : Type*} [MeasurableSpace α] {μ : Measure α}
+    {f : α → α} (hf : MeasurePreserving f μ μ) :
+    @MeasurePreserving (NullMeasurableSpace α μ) (NullMeasurableSpace α μ) _ _
+      f μ.completion μ.completion := by
+  have hm : @Measurable (NullMeasurableSpace α μ) (NullMeasurableSpace α μ) _ _ f := by
+    intro s hs
+    change NullMeasurableSet (f ⁻¹' s) μ
+    exact NullMeasurableSet.preimage (μb := μ) (show NullMeasurableSet (show Set α from s) μ from hs) hf.quasiMeasurePreserving
+  refine ⟨hm, ?_⟩
+  apply Measure.ext
+  intro s hs
+  rw [Measure.map_apply hm hs]
+  exact hf.measure_preimage hs
+
+lemma ergodic_completion {α : Type*} [MeasurableSpace α] {μ : Measure α}
+    {f : α → α} (hf : Ergodic f μ) :
+    @Ergodic (NullMeasurableSpace α μ) _ f μ.completion := by
+  refine ⟨measurePreserving_completion hf.toMeasurePreserving, ?_⟩
+  constructor
+  intro s hs he
+  exact hf.quasiErgodic.aeconst_set₀ hs (Filter.EventuallyEq.of_eq he)
+
+
+abbrev Base := NullMeasurableSpace (PadicInt 2) baseHaar
+abbrev baseMeasure : Measure Base := baseHaar.completion
+instance base_probability : IsProbabilityMeasure baseMeasure := ⟨measure_univ (μ := baseHaar)⟩
+instance base_nullSingleton : NullSingletonClass baseMeasure := by
+  constructor
+  intro x
+  change baseHaar { (show PadicInt 2 from x) } = 0
+  exact measure_singleton _
+instance base_measurableSingleton : MeasurableSingletonClass Base := by
+  constructor
+  intro x
+  exact measurableSet_of_null (μ := baseMeasure) (measure_singleton x)
+
+def odometer : Base → Base := odometerBorel
+lemma odometer_ergodic : Ergodic odometer baseMeasure := by
+  change @Ergodic (NullMeasurableSpace (PadicInt 2) baseHaar) _ odometerBorel baseHaar.completion
+  exact ergodic_completion (α := PadicInt 2) odometerBorel_ergodic
+
+def residue (m : ℕ) (x : Base) : ℕ := twoResidue m x
+lemma residue_lt (m : ℕ) (x : Base) : residue m x < 2^m := twoResidue_lt m x
+lemma measurable_residue (m : ℕ) : Measurable (residue m) :=
+  (measurable_twoResidue m).nullMeasurable.measurable'
+
+
+
+def goodBase : Set Base := (Set.range (fun n : ℤ => (show Base from (n : PadicInt 2))))ᶜ
+lemma measurableSet_goodBase : MeasurableSet goodBase := by
+  apply MeasurableSet.compl
+  exact (Set.countable_range _).measurableSet
+lemma ae_goodBase : ∀ᵐ x ∂baseMeasure, x ∈ goodBase :=
+  (Set.countable_range (fun n : ℤ => (show Base from (n : PadicInt 2)))).ae_notMem baseMeasure
+lemma goodBase_odometer (x : Base) : odometer x ∈ goodBase ↔ x ∈ goodBase := by
+  change ((show PadicInt 2 from x)+1:PadicInt 2) ∉ Set.range (Int.cast : ℤ → PadicInt 2) ↔
+    x ∉ Set.range (Int.cast : ℤ → PadicInt 2)
+  apply not_congr
+  constructor
+  · rintro ⟨n, hn⟩
+    refine ⟨n-1, ?_⟩
+    push_cast
+    rw [hn]
+    change ((show PadicInt 2 from x)+1)-1 = (show PadicInt 2 from x)
+    exact add_sub_cancel_right _ _
+  · rintro ⟨n, rfl⟩
+    exact ⟨n+1, by push_cast; rfl⟩
+
+lemma zmod_val_neg_one {N : ℕ} (hN : 0 < N) : (-1 : ZMod N).val = N-1 := by
+  obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hN)
+  simp [ZMod.val_neg_one]
+
+lemma residue_exceptional_iff (m : ℕ) (x : Base) :
+    residue m x = 2^m-1 ↔ PadicInt.toZModPow m x = (-1 : ZMod (2^m)) := by
+  change (PadicInt.toZModPow m x).val = _ ↔ _
+  rw [← zmod_val_neg_one (pow_pos (by norm_num : 0 < 2) m)]
+  exact (ZMod.val_injective (2^m)).eq_iff
+
+lemma goodBase_eventually_nonexceptional {x : Base} (hx : x ∈ goodBase) :
+    ∃ M : ℕ, ∀ m ≥ M, residue m x ≠ 2^m-1 := by
+  have hx' : (show PadicInt 2 from x) ≠ -1 := by
+    intro h
+    apply hx
+    refine ⟨-1, ?_⟩
+    change ((-1:ℤ):PadicInt 2) = (show PadicInt 2 from x)
+    simpa using h.symm
+  have hex : ∃ M, PadicInt.toZModPow M x ≠ PadicInt.toZModPow M (-1:PadicInt 2) := by
+    by_contra! h
+    exact hx' (PadicInt.ext_of_toZModPow.mp h)
+  obtain ⟨M, hM⟩ := hex
+  refine ⟨M, fun m hm he => hM ?_⟩
+  have heq := (residue_exceptional_iff m x).mp he
+  have hc := congrArg (ZMod.castHom (pow_dvd_pow 2 hm) (ZMod (2^M))) heq
+  change ZMod.cast (PadicInt.toZModPow m (show PadicInt 2 from x)) = _ at hc
+  rw [PadicInt.cast_toZModPow M m hm] at hc
+  simpa only [map_neg, map_one] using hc
+
+lemma residue_step {m : ℕ} (hm : 1 ≤ m) (x : Base) :
+    residue m (odometer x) = if residue m x = 2^m-1 then 0 else residue m x + 1 := by
+  have hN' : 2 ≤ 2^m := by simpa using Nat.pow_le_pow_right (by norm_num : 0 < 2) hm
+  have hN : 1 < 2^m := by omega
+  have : Fact (1 < 2^m) := ⟨hN⟩
+  change ((PadicInt.toZModPow m) ((show PadicInt 2 from x)+1)).val = _
+  rw [map_add, map_one, ZMod.val_add, ZMod.val_one]
+  change (residue m x + 1) % 2^m = _
+  have hr := residue_lt m x
+  split_ifs with h
+  · have he : residue m x+1 = 2^m := by omega
+    simp [he]
+  · exact Nat.mod_eq_of_lt (by omega)
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/HilbertClassification.lean

@@ -0,0 +1,101 @@
+import OAI.Analysis.BackwardIntertwiners.ModelProperties
+
+namespace OAI
+
+namespace Hyperinvariant233
+open Filter
+open scoped Topology
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+
+def commutant (T : H →L[ℂ] H) : Subalgebra ℂ (H →L[ℂ] H) :=
+  Subalgebra.centralizer ℂ ({T} : Set (H →L[ℂ] H))
+
+
+def TransitiveCommutant (T : H →L[ℂ] H) : Prop :=
+  ∀ K : Submodule ℂ H, IsClosed (K : Set H) →
+    (∀ A : H →L[ℂ] H, A * T = T * A → ∀ x ∈ K, A x ∈ K) →
+    K = ⊥ ∨ K = ⊤
+
+
+@[instance_reducible]
+def strongOperatorTopology : TopologicalSpace (H →L[ℂ] H) :=
+  TopologicalSpace.induced (fun A : H →L[ℂ] H => (fun x : H => A x)) inferInstance
+
+
+def MainClaim : Prop :=
+  ∃ T : H →L[ℂ] H, T ≠ 0 ∧
+    Tendsto (fun n : ℕ => ‖T ^ n‖ ^ (1 / (n : ℝ))) atTop (𝓝 0) ∧
+    TransitiveCommutant T
+
+
+def FullClaim : Prop :=
+  ∃ T : H →L[ℂ] H, T ≠ 0 ∧
+    Tendsto (fun n : ℕ => ‖T ^ n‖ ^ (1 / (n : ℝ))) atTop (𝓝 0) ∧
+    TransitiveCommutant T ∧ commutant T ≠ ⊤ ∧
+    @IsClosed (H →L[ℂ] H) strongOperatorTopology (commutant T : Set (H →L[ℂ] H))
+
+end Hyperinvariant233
+
+
+namespace Hyperinvariant233
+open Submodule TopologicalSpace
+universe u v
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+  [CompleteSpace H] [SeparableSpace H]
+
+
+theorem orthonormal_subtype_countable (w : Set H)
+    (hw : Orthonormal ℂ (Subtype.val : w → H)) : Countable w := by
+  classical
+  let : DiscreteTopology w := discreteTopology_iff_isOpen_singleton.mpr (by
+    intro i
+    have ho : IsOpen {j : w | (1 / 2 : ℝ) < ‖inner ℂ (i : H) (j : H)‖} :=
+      isOpen_lt continuous_const (continuous_const.inner continuous_subtype_val).norm
+    have he : {j : w | (1 / 2 : ℝ) < ‖inner ℂ (i : H) (j : H)‖} = {i} := by
+      ext j
+      rw [Set.mem_ofPred_eq, orthonormal_iff_ite.mp hw i j]
+      by_cases hij : i = j <;> norm_num [hij, eq_comm]
+    rwa [he] at ho)
+  exact separableSpace_iff_countable.mp inferInstance
+
+
+
+theorem exists_nat_hilbertBasis (hInf : ¬FiniteDimensional ℂ H) :
+    Nonempty (HilbertBasis ℕ ℂ H) := by
+  classical
+  obtain ⟨w, b, hb⟩ := exists_hilbertBasis ℂ H
+  have hw : Orthonormal ℂ (Subtype.val : w → H) := by
+    simpa only [hb] using b.orthonormal
+  let : Countable w := orthonormal_subtype_countable w hw
+  let : Infinite w := by
+    refine not_finite_iff_infinite.mp ?_
+    intro hfin
+    let : Finite w := hfin
+    let : Fintype w := Fintype.ofFinite w
+    exact hInf (Module.Finite.of_basis b.toOrthonormalBasis.toBasis)
+  let e : ℕ ≃ w := Classical.choice (inferInstance : Nonempty (ℕ ≃ w))
+  have ho : Orthonormal ℂ (b ∘ e) := b.orthonormal.comp e e.injective
+  have hr : Set.range (b ∘ e) = Set.range b := by
+    ext x
+    constructor
+    · rintro ⟨n, rfl⟩
+      exact ⟨e n, rfl⟩
+    · rintro ⟨i, rfl⟩
+      exact ⟨e.symm i, by simp⟩
+  exact ⟨HilbertBasis.mk ho (by rw [hr, b.dense_span])⟩
+
+
+theorem nonempty_linearIsometryEquiv
+    {K : Type v} [NormedAddCommGroup K] [InnerProductSpace ℂ K]
+    [CompleteSpace K] [SeparableSpace K]
+    (hH : ¬FiniteDimensional ℂ H) (hK : ¬FiniteDimensional ℂ K) :
+    Nonempty (H ≃ₗᵢ[ℂ] K) := by
+  obtain ⟨bH⟩ := exists_nat_hilbertBasis hH
+  obtain ⟨bK⟩ := exists_nat_hilbertBasis hK
+  exact ⟨bH.repr.trans bK.repr.symm⟩
+
+end Hyperinvariant233
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ModelProperties.lean

@@ -0,0 +1,133 @@
+import OAI.Analysis.BackwardIntertwiners.ProductSymbols
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+attribute [local instance] realOperatorTower realOperatorCommute complexNormalCalculus complexClosedCalculus realSelfAdjointCalculus
+
+open InnerProductSpace ContinuousLinearMap
+
+
+structure OrdinaryStructuralProperties (D : DirectModelData) : Prop where
+  tails : ∀ h : ℤ, ∃ L : Submodule ℂ GlobalHilbert,
+    (∀ f : GlobalHilbert, f ∈ L ↔ ∀ᵐ x ∂baseMeasure, f x ∈ coordinateTail h) ∧
+    IsClosed (L : Set GlobalHilbert) ∧ L ≠ ⊥ ∧ L ≠ ⊤ ∧
+    OperatorInvariant L D.S ∧ ¬OperatorInvariant L D.V
+  fiber_compact : ∀ x : Base, IsCompactOperator (D.Sx x)
+  global_not_compact : ¬IsCompactOperator D.S
+  multiplier_witness : ∃ Q : GlobalHilbert →L[ℂ] GlobalHilbert,
+    IsStarProjection Q ∧
+    (∀ f : GlobalHilbert, Q f =ᵐ[baseMeasure] fun x => lp.single 2 0 (f x 0)) ∧
+    Q * D.S ≠ D.S * Q ∧
+    (∀ g : Lp ℂ ∞ baseMeasure, Q * scalarMultiplier g = scalarMultiplier g * Q) ∧
+    Q ∉ Set.range (scalarMultiplier (μ:=baseMeasure))
+
+
+
+
+structure PolarFamilyProperties (D : DirectModelData)
+    (U : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ)
+    (A : ℤ → GlobalHilbert →L[ℂ] GlobalHilbert) : Prop where
+  unitary : star (U : GlobalHilbert →L[ℂ] GlobalHilbert) =
+    ((U⁻¹ : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ) : GlobalHilbert →L[ℂ] GlobalHilbert)
+  unitary_coordinates : ∀ f : GlobalHilbert, ∀ᵐ x ∂baseMeasure, ∀ j : ℤ,
+    (U : GlobalHilbert →L[ℂ] GlobalHilbert) f x j = f x (j-1)
+  modulus : A 0 = CFC.sqrt (star D.S * D.S)
+  polar : D.S = (U : GlobalHilbert →L[ℂ] GlobalHilbert) * A 0
+  injective : Function.Injective (A 0)
+  dense_range : DenseRange (A 0)
+  conjugates : ∀ n : ℤ, A n =
+    ((U^(-n) : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ) : GlobalHilbert →L[ℂ] GlobalHilbert) *
+      A 0 * ((U^n : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ) : GlobalHilbert →L[ℂ] GlobalHilbert)
+  diagonal : ∀ n : ℤ, ∀ f : GlobalHilbert, ∀ᵐ x ∂baseMeasure, ∀ j : ℤ,
+    A n f x j = (explicitBeta x (j+n):ℂ) * f x j
+  finite_atomic : ∀ F : Finset ℤ, AtomicAlgebra (strongGenerated (A '' (F : Set ℤ)))
+  modulus_pure_point : PurePointResolution (A 0)
+  full_multiplication : ∀ T : GlobalHilbert →L[ℂ] GlobalHilbert,
+    T ∈ strongGenerated (Set.range A) ↔ IsProductMultiplier T
+  abelian : ∀ T ∈ strongGenerated (Set.range A), ∀ R ∈ strongGenerated (Set.range A), T*R=R*T
+  diffuse : DiffuseAlgebra (strongGenerated (Set.range A))
+  not_contained_in_commutant : ∃ T ∈ strongGenerated (Set.range A), T * D.S ≠ D.S * T
+
+def PolarStructuralProperties (D : DirectModelData) : Prop :=
+  ∃ (U : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ)
+    (A : ℤ → GlobalHilbert →L[ℂ] GlobalHilbert), PolarFamilyProperties D U A
+
+
+lemma coordinateTail_eq_closedSpan (h : ℤ) :
+    coordinateTail h = (Submodule.span ℂ
+      (Set.range (fun j : {j : ℤ // h ≤ j} => (lp.single 2 j.val (1:ℂ) : Fiber)))).topologicalClosure := by
+  let P := Submodule.span ℂ (Set.range (fun j : {j : ℤ // h ≤ j} => (lp.single 2 j.val (1:ℂ) : Fiber)))
+  apply le_antisymm
+  · intro v hv
+    apply (Submodule.isClosed_topologicalClosure P).mem_of_tendsto
+      (lp.hasSum_single (by norm_num : (2:ENNReal) ≠ ∞) v)
+    apply Eventually.of_forall
+    intro s
+    apply P.topologicalClosure.sum_mem
+    intro j _
+    by_cases hj : j < h
+    · rw [hv j hj,lp.single_zero]
+      exact P.topologicalClosure.zero_mem
+    · apply Submodule.le_topologicalClosure
+      have hg : (lp.single 2 j (1:ℂ) : Fiber) ∈ P :=
+        Submodule.subset_span ⟨⟨j,by omega⟩,rfl⟩
+      simpa only [←lp.single_smul,smul_eq_mul,mul_one] using P.smul_mem (v j) hg
+  · apply Submodule.topologicalClosure_minimal _ ?_ (coordinateTail_isClosed h)
+    apply Submodule.span_le.mpr
+    rintro v ⟨j,rfl⟩
+    exact single_mem_coordinateTail j.property 1
+
+lemma explicitDirectModel_ordinary : OrdinaryStructuralProperties explicitDirectModel where
+  tails h := ⟨globalTail h, fun f => mem_globalTail h f,
+    globalTail_closed h,globalTail_nonzero h,globalTail_proper h,
+    globalTail_forward h,globalTail_not_backward h⟩
+  fiber_compact := forwardFiber_compact
+  global_not_compact := forwardOperator_not_compact
+  multiplier_witness := ⟨sliceProjection 0, sliceProjection_isStarProjection 0,
+    sliceProjection_ae 0,sliceProjection_zero_not_commute,
+    sliceProjection_scalar_commute 0,sliceProjection_zero_not_scalar⟩
+
+lemma explicitDirectModel_polarFamily : PolarFamilyProperties explicitDirectModel shiftUnit polarDiagonal where
+  unitary := coordinateShift_star 1
+  unitary_coordinates := coordinateShift_ae 1
+  modulus := polar_modulus.symm
+  polar := forward_polar_factor
+  injective := polarDiagonal_injective
+  dense_range := polarDiagonal_denseRange
+  conjugates n := by
+    rw [shiftUnit_zpow,shiftUnit_zpow]
+    exact (polarDiagonal_conjugate n).symm
+  diagonal := polarDiagonal_ae
+  finite_atomic := finitePolarAlgebra_atomic
+  modulus_pure_point := polarDiagonal_purePoint
+  full_multiplication := polarAlgebra_mem_iff_productMultiplier
+  abelian := fun _ hT _ hR => polarAlgebra_commutative hT hR
+  diffuse := polarAlgebra_diffuse
+  not_contained_in_commutant := ⟨polarDiagonal 0,polarDiagonal_mem 0,polarDiagonal_not_commute⟩
+
+
+
+
+theorem direct_model_complete : ∃ D : DirectModelData,
+    DirectModelProperties D ∧ OrdinaryStructuralProperties D ∧ PolarStructuralProperties D := by
+  exact ⟨explicitDirectModel,explicitDirectModel_properties,
+    explicitDirectModel_ordinary,shiftUnit,polarDiagonal,explicitDirectModel_polarFamily⟩
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/OperatorTransport.lean

@@ -0,0 +1,157 @@
+import OAI.Analysis.BackwardIntertwiners.HilbertClassification
+
+namespace OAI
+
+namespace Hyperinvariant233
+open Filter
+open scoped Topology
+universe u v
+variable {H : Type u} {K : Type v}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+
+theorem norm_conjugate_le (e : H ≃ₗᵢ[ℂ] K) (T : H →L[ℂ] H) :
+    ‖e.conjStarAlgEquiv T‖ ≤ ‖T‖ := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg _)
+  intro x
+  change ‖e (T (e.symm x))‖ ≤ ‖T‖ * ‖x‖
+  rw [e.norm_map]
+  simpa only [e.symm.norm_map] using T.le_opNorm (e.symm x)
+
+theorem norm_conjugate (e : H ≃ₗᵢ[ℂ] K) (T : H →L[ℂ] H) :
+    ‖e.conjStarAlgEquiv T‖ = ‖T‖ := by
+  apply le_antisymm (norm_conjugate_le e T)
+  have he : e.symm.conjStarAlgEquiv (e.conjStarAlgEquiv T) = T := by
+    ext x
+    simp only [LinearIsometryEquiv.conjStarAlgEquiv_apply_apply,
+      LinearIsometryEquiv.symm_symm, LinearIsometryEquiv.symm_apply_apply]
+  have h := norm_conjugate_le e.symm (e.conjStarAlgEquiv T)
+  rwa [he] at h
+
+
+theorem transitiveCommutant_conjugate (e : H ≃ₗᵢ[ℂ] K) (T : H →L[ℂ] H)
+    (hT : TransitiveCommutant T) : TransitiveCommutant (e.conjStarAlgEquiv T) := by
+  intro W hW hInv
+  let U : Submodule ℂ H := W.comap e.toLinearMap
+  have hU : IsClosed (U : Set H) := hW.preimage e.continuous
+  have hUI : ∀ A : H →L[ℂ] H, A * T = T * A → ∀ x ∈ U, A x ∈ U := by
+    intro A hA x hx
+    change e (A x) ∈ W
+    have hc : e.conjStarAlgEquiv A * e.conjStarAlgEquiv T =
+        e.conjStarAlgEquiv T * e.conjStarAlgEquiv A := by
+      simpa only [map_mul] using congrArg e.conjStarAlgEquiv hA
+    have hm := hInv (e.conjStarAlgEquiv A) hc (e x) hx
+    simpa using hm
+  rcases hT U hU hUI with hz | ho
+  · left
+    apply le_antisymm _ bot_le
+    intro y hy
+    have hx : e.symm y ∈ U := by change e (e.symm y) ∈ W; simpa using hy
+    rw [hz] at hx
+    have hzero : e.symm y = 0 := hx
+    have := congrArg e hzero
+    simpa using this
+  · right
+    apply le_antisymm le_top
+    intro y _
+    have hx : e.symm y ∈ U := by rw [ho]; trivial
+    change e (e.symm y) ∈ W at hx
+    simpa using hx
+
+
+theorem mainClaim_transport (e : H ≃ₗᵢ[ℂ] K) (h : MainClaim (H := H)) :
+    MainClaim (H := K) := by
+  obtain ⟨T, hT0, hq, ht⟩ := h
+  refine ⟨e.conjStarAlgEquiv T, ?_, ?_, transitiveCommutant_conjugate e T ht⟩
+  · exact fun hzero => hT0 (e.conjStarAlgEquiv.injective (by simpa using hzero))
+  · have he : (fun n : ℕ => ‖(e.conjStarAlgEquiv T) ^ n‖ ^ (1 / (n : ℝ))) =
+        (fun n : ℕ => ‖T ^ n‖ ^ (1 / (n : ℝ))) := by
+      funext n
+      rw [← map_pow, norm_conjugate]
+    rwa [he]
+
+end Hyperinvariant233
+
+
+namespace Hyperinvariant233
+open Filter
+open scoped Topology
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+
+
+theorem mem_commutant_iff (T A : H →L[ℂ] H) :
+    A ∈ commutant T ↔ A * T = T * A := by
+  simp only [commutant, Subalgebra.mem_centralizer_iff, Set.mem_singleton_iff, forall_eq]
+  exact eq_comm
+
+variable [completeSpace : CompleteSpace H]
+
+
+
+omit completeSpace in
+theorem commutant_isClosed_strong [CompleteSpace H] (T : H →L[ℂ] H) :
+    @IsClosed (H →L[ℂ] H) strongOperatorTopology (commutant T : Set (H →L[ℂ] H)) := by
+  let : TopologicalSpace (H →L[ℂ] H) := strongOperatorTopology
+  have heval : ∀ x : H, Continuous (fun A : H →L[ℂ] H => A x) := by
+    intro x
+    exact (continuous_apply x).comp continuous_induced_dom
+  have hset : (commutant T : Set (H →L[ℂ] H)) =
+      ⋂ x : H, {A : H →L[ℂ] H | A (T x) = T (A x)} := by
+    ext A
+    simp only [Set.mem_iInter, Set.mem_ofPred_eq, SetLike.mem_coe, mem_commutant_iff]
+    constructor
+    · intro h x
+      exact congrArg (fun B : H →L[ℂ] H => B x) h
+    · intro h
+      ext x
+      exact h x
+  rw [hset]
+  exact isClosed_iInter (fun x => isClosed_eq (heval (T x)) (T.continuous.comp (heval x)))
+
+
+
+omit completeSpace in
+theorem scalar_of_commutant_top [CompleteSpace H] (T : H →L[ℂ] H) (h : commutant T = ⊤) :
+    ∃ c : ℂ, algebraMap ℂ (H →L[ℂ] H) c = T := by
+  have hc : T ∈ Subalgebra.center ℂ (H →L[ℂ] H) := by
+    rw [Subalgebra.mem_center_iff]
+    intro A
+    apply (mem_commutant_iff T A).mp
+    rw [h]
+    trivial
+  rw [Algebra.IsCentral.center_eq_bot] at hc
+  exact Algebra.mem_bot.mp hc
+
+
+
+theorem commutant_ne_top_of_nonzero_quasinilpotent [Nontrivial H]
+    (T : H →L[ℂ] H) (hT : T ≠ 0)
+    (hlim : Tendsto (fun n : ℕ => ‖T ^ n‖ ^ (1 / (n : ℝ))) atTop (𝓝 0)) :
+    commutant T ≠ ⊤ := by
+  intro htop
+  obtain ⟨c, hc⟩ := scalar_of_commutant_top T htop
+  have hroot (n : ℕ) (hn : n ≠ 0) : ‖T ^ n‖ ^ (1 / (n : ℝ)) = ‖c‖ := by
+    rw [← hc, Algebra.algebraMap_eq_smul_one, smul_pow, one_pow,
+      norm_smul, norm_pow, norm_one, mul_one, one_div]
+    exact Real.pow_rpow_inv_natCast (norm_nonneg c) hn
+  have hevent : (fun n : ℕ => ‖T ^ n‖ ^ (1 / (n : ℝ))) =ᶠ[atTop]
+      (fun _ : ℕ => ‖c‖) := by
+    filter_upwards [eventually_gt_atTop 0] with n hn
+    exact hroot n (Nat.ne_of_gt hn)
+  have hconst : Tendsto (fun _ : ℕ => ‖c‖) atTop (𝓝 0) := hlim.congr' hevent
+  have hc0 : ‖c‖ = 0 := tendsto_nhds_unique tendsto_const_nhds hconst
+  apply hT
+  rw [← hc, norm_eq_zero.mp hc0, map_zero]
+
+
+theorem fullClaim_of_mainClaim [Nontrivial H] (h : MainClaim (H := H)) :
+    FullClaim (H := H) := by
+  obtain ⟨T, hT, hlim, htrans⟩ := h
+  exact ⟨T, hT, hlim, htrans,
+    commutant_ne_top_of_nonzero_quasinilpotent T hT hlim,
+    commutant_isClosed_strong T⟩
+
+end Hyperinvariant233
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/OrdinaryStructure.lean

@@ -0,0 +1,253 @@
+import OAI.Analysis.BackwardIntertwiners.ErgodicTransitivity
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+
+def globalTail (h : ℤ) : Submodule ℂ GlobalHilbert :=
+  ⨅ j : ℤ, ⨅ _ : j < h, (coordinateL2 j).ker
+lemma mem_globalTail (h : ℤ) (f : GlobalHilbert) :
+    f ∈ globalTail h ↔ ∀ᵐ x ∂baseMeasure, f x ∈ coordinateTail h := by
+  simp only [globalTail, Submodule.mem_iInf, LinearMap.mem_ker]
+  constructor
+  · intro hf
+    have h (j : ℤ) : ∀ᵐ x ∂baseMeasure, j < h → f x j = 0 := by
+      by_cases hj : j < h
+      · have hh := (Lp.eq_zero_iff_ae_eq_zero.mp (hf j hj))
+        filter_upwards [coordinateL2_ae j f, hh] with x hx hzero
+        intro _
+        exact hx.symm.trans hzero
+      · exact Filter.Eventually.of_forall fun _ => fun h => False.elim (hj h)
+    exact ae_all_iff.mpr h
+  · intro hf j hj
+    apply Lp.eq_zero_iff_ae_eq_zero.mpr
+    filter_upwards [hf, coordinateL2_ae j f] with x hx hcoord
+    exact hcoord.trans (hx j hj)
+lemma globalTail_closed (h : ℤ) : IsClosed (globalTail h : Set GlobalHilbert) := by
+  have he : (globalTail h : Set GlobalHilbert) = ⋂ j : ℤ, ⋂ _ : j < h,
+      {f : GlobalHilbert | coordinateL2 j f = 0} := by ext; simp [globalTail]
+  rw [he]
+  exact isClosed_iInter fun j => isClosed_iInter fun _ =>
+    isClosed_eq (coordinateL2 j).continuous continuous_const
+lemma constantBasis_mem_globalTail {h j : ℤ} (hj : h ≤ j) : constantBasis j ∈ globalTail h := by
+  rw [mem_globalTail]
+  filter_upwards [constantBasis_ae j] with x hx
+  rw [hx]
+  exact single_mem_coordinateTail hj 1
+lemma constantBasis_not_mem_globalTail {h j : ℤ} (hj : j < h) : constantBasis j ∉ globalTail h := by
+  intro hm
+  have hh := (mem_globalTail h _).mp hm
+  have hz : ∀ᵐ x ∂baseMeasure, (1:ℂ) = 0 := by
+    filter_upwards [hh, constantBasis_ae j] with x hx he
+    simpa only [he, lp.single_apply_self] using hx j hj
+  exact one_ne_zero hz.exists.choose_spec
+lemma globalTail_nonzero (h : ℤ) : globalTail h ≠ ⊥ := by
+  intro he
+  have hmem := constantBasis_mem_globalTail (le_refl h)
+  rw [he] at hmem
+  have hm : constantBasis h = 0 := hmem
+  have hn := constantBasis_norm h
+  rw [hm, norm_zero] at hn
+  norm_num at hn
+lemma globalTail_proper (h : ℤ) : globalTail h ≠ ⊤ := by
+  intro he
+  apply constantBasis_not_mem_globalTail (show h-1<h by omega)
+  rw [he]; trivial
+lemma globalTail_forward (h : ℤ) : OperatorInvariant (globalTail h) forwardOperator := by
+  intro f hf
+  rw [mem_globalTail] at hf ⊢
+  filter_upwards [hf, forwardOperator_ae f] with x hx he
+  rw [he]
+  exact forwardFiber_tail x h hx
+lemma globalTail_not_backward (h : ℤ) : ¬OperatorInvariant (globalTail h) backwardOperator := by
+  intro hinv
+  have hm := (mem_globalTail h _).mp (hinv _ (constantBasis_mem_globalTail (le_refl h)))
+  have hgood := inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae.eventually ae_goodBase
+  have he := (constantBasis_ae h).comp_tendsto inverseOdometer_preserving.quasiMeasurePreserving.tendsto_ae
+  have hh : ∀ᵐ x ∂baseMeasure, False := by
+    filter_upwards [hm, backwardOperator_ae_inverse (constantBasis h), he, hgood] with x hx hV h₀ hg
+    dsimp only [Function.comp_def] at h₀
+    have hz := hx (h-1) (by omega)
+    rw [hV, backwardFiber_apply, sub_add_cancel, h₀, lp.single_apply_self, mul_one] at hz
+    exact (ne_of_gt (backwardCoeff_pos hg h)) (Complex.ofReal_eq_zero.mp hz)
+  exact hh.exists.choose_spec
+
+
+def sliceProjection (j : ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  (singleL2 j).comp (coordinateL2 j)
+lemma sliceProjection_ae (j : ℤ) (f : GlobalHilbert) :
+    sliceProjection j f =ᵐ[baseMeasure] fun x => lp.single 2 j (f x j) := by
+  filter_upwards [singleL2_ae j (coordinateL2 j f), coordinateL2_ae j f] with x h₁ h₂
+  change singleL2 j (coordinateL2 j f) x = _
+  rw [h₁, h₂]
+lemma sliceProjection_singleL2 (j : ℤ) (f : ScalarHilbert) :
+    sliceProjection j (singleL2 j f) = singleL2 j f := by
+  change singleL2 j (coordinateL2 j (singleL2 j f)) = _
+  rw [coordinateL2_singleL2]
+lemma sliceProjection_idempotent (j : ℤ) : sliceProjection j * sliceProjection j = sliceProjection j := by
+  ext1 f
+  exact sliceProjection_singleL2 j (coordinateL2 j f)
+lemma sliceProjection_constantBasis (j k : ℤ) :
+    sliceProjection j (constantBasis k) = if j=k then constantBasis k else 0 := by
+  classical
+  apply Lp.ext
+  filter_upwards [sliceProjection_ae j (constantBasis k), constantBasis_ae k,
+    Lp.coeFn_zero (E:=Fiber) (p:=2) (μ:=baseMeasure)] with x hx he hz
+  rw [hx, he]
+  by_cases hh : j=k
+  · simp [hh, he]
+  · simp only [ite_eq_right hh, lp.single_apply_ne _ _ _ hh, lp.single_zero, hz, Pi.zero_apply]
+lemma sliceProjection_scalar_commute (j : ℤ) (g : Lp ℂ ∞ baseMeasure) :
+    sliceProjection j * scalarMultiplier g = scalarMultiplier g * sliceProjection j := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [sliceProjection_ae j (scalarMultiplier g f), scalarMultiplier_ae g f,
+    scalarMultiplier_ae g (sliceProjection j f), sliceProjection_ae j f] with x h₁ h₂ h₃ h₄
+  change sliceProjection j (scalarMultiplier g f) x = scalarMultiplier g (sliceProjection j f) x
+  rw [h₁,h₂,h₃,h₄]
+  exact lp.single_smul (E:=fun _ : ℤ => ℂ) 2 j (g x) (f x j)
+lemma sliceProjection_zero_not_commute :
+    sliceProjection 0 * forwardOperator ≠ forwardOperator * sliceProjection 0 := by
+  intro he
+  have h := congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T (constantBasis 0)) he
+  simp only [mul_apply_eq_comp, forwardOperator_constantBasis_zero, map_smul,
+    sliceProjection_constantBasis] at h
+  norm_num at h
+  have hh := congrArg norm h
+  rw [norm_zero, forwardOperator_constantBasis_zero, norm_smul, constantBasis_norm, mul_one, Complex.norm_real,
+    Real.norm_of_nonneg (Real.exp_pos _).le] at hh
+  exact (Real.exp_ne_zero (-10)) hh.symm
+lemma sliceProjection_zero_not_scalar :
+    sliceProjection 0 ∉ Set.range (scalarMultiplier (μ:=baseMeasure)) := by
+  rintro ⟨g,hg⟩
+  have he0 : scalarMultiplier g (constantBasis 0) = constantBasis 0 := by
+    rw [hg, sliceProjection_constantBasis]; simp
+  have he1 : scalarMultiplier g (constantBasis 1) = 0 := by
+    rw [hg, sliceProjection_constantBasis]; norm_num
+  have h₀ := scalarMultiplier_ae g (constantBasis 0)
+  have h₁ := scalarMultiplier_ae g (constantBasis 1)
+  rw [he0] at h₀
+  rw [he1] at h₁
+  have hfalse : ∀ᵐ x ∂baseMeasure, False := by
+    filter_upwards [h₀,h₁,constantBasis_ae 0, constantBasis_ae 1,
+      Lp.coeFn_zero (E:=Fiber) (p:=2) (μ:=baseMeasure)] with x hv₀ hv₁ he₀ he₁ hz
+    have hc₀ := congrArg (fun v : Fiber => v 0) hv₀
+    have hc₁ := congrArg (fun v : Fiber => v 1) hv₁
+    simp only [he₀, lp.single_apply_self, lp.coeFn_smul, Pi.smul_apply, smul_eq_mul, mul_one] at hc₀
+    simp only [hz, he₁, lp.single_apply_self, lp.coeFn_smul, Pi.smul_apply, smul_eq_mul, mul_one, lp.coeFn_zero, Pi.zero_apply] at hc₁
+    exact one_ne_zero (hc₀.trans hc₁.symm)
+  exact hfalse.exists.choose_spec
+
+lemma residue_separates {x y : Base} (h : ∀ m : ℕ, residue m x = residue m y) : x = y := by
+  apply PadicInt.ext_of_toZModPow.mp
+  intro m
+  apply ZMod.val_injective
+  exact h m
+
+def residueClass (m t : ℕ) : Set Base := {x | residue m x = t}
+lemma measurableSet_residueClass (m t : ℕ) : MeasurableSet (residueClass m t) :=
+  measurableSet_eq_fun (measurable_residue m) measurable_const
+lemma residueClass_nonnull {m t : ℕ} (ht : t < 2^m) : baseMeasure (residueClass m t) ≠ 0 := by
+  change baseHaar {x : PadicInt 2 | twoResidue m x = t} ≠ 0
+  have hcont : Continuous (twoResidue m) :=
+    continuous_of_discreteTopology.comp (continuous_twoResidue m)
+  have hOpen : IsOpen {x : PadicInt 2 | twoResidue m x = t} :=
+    (isOpen_discrete ({t}:Set ℕ)).preimage hcont
+  have hmem : twoResidue m (t : PadicInt 2) = t := by
+    simp only [twoResidue, map_natCast]
+    exact ZMod.val_natCast_of_lt ht
+  exact (hOpen.measure_pos baseHaar ⟨(t : PadicInt 2),hmem⟩).ne'
+
+
+def residueIndicator (m t : ℕ) : ScalarHilbert :=
+  indicatorConstLp 2 (measurableSet_residueClass m t) (measure_ne_top baseMeasure _) (1:ℂ)
+lemma residueIndicator_ae (m t : ℕ) : residueIndicator m t =ᵐ[baseMeasure]
+    (residueClass m t).indicator (fun _ => (1:ℂ)) := indicatorConstLp_coeFn
+lemma residueIndicator_ne_zero {m t : ℕ} (ht : t < 2^m) : residueIndicator m t ≠ 0 := by
+  intro hz
+  apply residueClass_nonnull ht
+  rw [measure_eq_zero_iff_ae_notMem]
+  have he := Lp.eq_zero_iff_ae_eq_zero.mp hz
+  filter_upwards [he,residueIndicator_ae m t] with x hx hi
+  intro hmem
+  have h10 : (1:ℂ)=0 := by rw [← Set.indicator_of_mem hmem (fun _ => (1:ℂ)), ← hi]; exact hx
+  exact one_ne_zero h10
+lemma residueIndicator_orthogonal (m : ℕ) {s t : ℕ} (hst : s ≠ t) :
+    inner ℂ (residueIndicator m s) (residueIndicator m t) = 0 := by
+  rw [L2.inner_def]
+  apply integral_eq_zero_of_ae
+  filter_upwards [residueIndicator_ae m s, residueIndicator_ae m t] with x hs ht
+  rw [hs,ht]
+  by_cases hxs : x ∈ residueClass m s
+  · have hxt : x ∉ residueClass m t := fun hx => hst (hxs.symm.trans hx)
+    simp [Set.indicator_of_notMem hxt]
+  · simp [Set.indicator_of_notMem hxs]
+lemma residueIndicator_independent (m : ℕ) :
+    LinearIndependent ℂ (fun t : Fin (2^m) => residueIndicator m t) := by
+  apply linearIndependent_of_ne_zero_of_inner_eq_zero
+  · intro t; exact residueIndicator_ne_zero t.isLt
+  · intro s t hst
+    exact residueIndicator_orthogonal m (fun he => hst (Fin.ext he))
+lemma scalarHilbert_infinite : ¬FiniteDimensional ℂ ScalarHilbert := by
+  intro hfin
+  let := hfin
+  have hh := (residueIndicator_independent (Module.finrank ℂ ScalarHilbert + 1)).fintype_card_le_finrank
+  simp only [Fintype.card_fin] at hh
+  have hlt := Nat.lt_two_pow_self (n:=Module.finrank ℂ ScalarHilbert + 1)
+  omega
+
+lemma forwardOperator_singleL2_zero (f : ScalarHilbert) :
+    forwardOperator (singleL2 0 f) = (Real.exp (-10):ℂ) • singleL2 1 f := by
+  apply Lp.ext
+  filter_upwards [forwardOperator_ae (singleL2 0 f), singleL2_ae 0 f, singleL2_ae 1 f,
+    Lp.coeFn_smul (Real.exp (-10):ℂ) (singleL2 1 f)] with x h₁ h₂ h₃ h₄
+  rw [h₁,h₂,h₄,Pi.smul_apply,h₃,forwardFiber_single,explicitBeta_zero]
+  exact lp.single_smul (E:=fun _ : ℤ => ℂ) 2 1 (Real.exp (-10):ℂ) (f x)
+lemma coordinate_forward_single :
+    (coordinateL2 1).comp (forwardOperator.comp (singleL2 0)) =
+      (Real.exp (-10):ℂ) • (1 : ScalarHilbert →L[ℂ] ScalarHilbert) := by
+  ext1 f
+  change coordinateL2 1 (forwardOperator (singleL2 0 f)) = (Real.exp (-10):ℂ) • f
+  rw [forwardOperator_singleL2_zero, map_smul, coordinateL2_singleL2]
+lemma forwardOperator_not_compact : ¬IsCompactOperator forwardOperator := by
+  intro hcomp
+  have hc : IsCompactOperator ((coordinateL2 1).comp (forwardOperator.comp (singleL2 0))) :=
+    (hcomp.comp_clm (singleL2 0)).clm_comp (coordinateL2 1)
+  rw [coordinate_forward_single] at hc
+  have he : (Real.exp (-10):ℂ) ≠ 0 := by exact_mod_cast Real.exp_ne_zero (-10)
+  have hid : IsCompactOperator (id : ScalarHilbert → ScalarHilbert) :=
+    (IsCompactOperator.smul_iff₀ he).mp hc
+  exact scalarHilbert_infinite (FiniteDimensional.of_isCompactOperator_id hid)
+lemma globalHilbert_infinite : ¬FiniteDimensional ℂ GlobalHilbert := by
+  intro hfin
+  let := hfin
+  apply scalarHilbert_infinite
+  apply FiniteDimensional.of_injective (singleL2 0).toLinearMap
+  intro f g he
+  have he' : singleL2 0 f = singleL2 0 g := he
+  simpa only [coordinateL2_singleL2] using congrArg (coordinateL2 0) he'
+
+lemma sliceProjection_selfAdjoint (j : ℤ) : IsSelfAdjoint (sliceProjection j) := by
+  apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr
+  intro f g
+  change inner ℂ (sliceProjection j f) g = inner ℂ f (sliceProjection j g)
+  simp only [L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [sliceProjection_ae j f, sliceProjection_ae j g] with x hf hg
+  rw [hf,hg,lp.inner_single_left,lp.inner_single_right]
+lemma sliceProjection_isStarProjection (j : ℤ) : IsStarProjection (sliceProjection j) :=
+  ⟨sliceProjection_idempotent j, sliceProjection_selfAdjoint j⟩
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/PolarDiagonals.lean

@@ -0,0 +1,368 @@
+import OAI.Analysis.BackwardIntertwiners.StrongClosure
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+
+def betaSymbol (n : ℤ) : DiagonalSymbol :=
+  ⟨fun x j => (explicitBeta x (j+n):ℂ),
+    ⟨fun j => Complex.continuous_ofReal.measurable.comp (measurable_explicitBeta (j+n)),
+      Real.exp (-10), (Real.exp_pos _).le, fun x j => by
+        simpa only [Complex.norm_real,Real.norm_of_nonneg (explicitBeta_pos _ _).le] using explicitBeta_le x (j+n)⟩⟩
+@[simp] lemma betaSymbol_apply (n : ℤ) (x : Base) (j : ℤ) :
+    betaSymbol n x j = (explicitBeta x (j+n):ℂ) := rfl
+lemma betaSymbol_star (n : ℤ) : star (betaSymbol n) = betaSymbol n := by
+  apply Subtype.ext
+  funext x j
+  simp
+
+def polarDiagonal (n : ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert := diagonalOperator (betaSymbol n)
+lemma polarDiagonal_ae (n : ℤ) (f : GlobalHilbert) :
+    ∀ᵐ x ∂baseMeasure, ∀ j, polarDiagonal n f x j = (explicitBeta x (j+n):ℂ)*f x j :=
+  diagonalOperator_coord _ _
+lemma polarDiagonal_selfAdjoint (n : ℤ) : IsSelfAdjoint (polarDiagonal n) := by
+  change star (diagonalOperator (betaSymbol n)) = diagonalOperator (betaSymbol n)
+  rw [←diagonalOperator_star,betaSymbol_star]
+lemma polarDiagonal_commute (m n : ℤ) : polarDiagonal m * polarDiagonal n = polarDiagonal n * polarDiagonal m := by
+  change diagonalRepresentation (betaSymbol m) * diagonalRepresentation (betaSymbol n) = diagonalRepresentation (betaSymbol n) * diagonalRepresentation (betaSymbol m)
+  rw [←map_mul,mul_comm,map_mul]
+
+
+
+def projectionSymbol (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) : DiagonalSymbol :=
+  ⟨fun x j => (E j).indicator (fun _ => (1:ℂ)) x,
+    ⟨fun j => measurable_const.indicator (hE j), 1, zero_le_one, fun x j => by
+      by_cases hx : x ∈ E j <;> simp [hx]⟩⟩
+@[simp] lemma projectionSymbol_apply (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j))
+    (x : Base) (j : ℤ) : projectionSymbol E hE x j = if x ∈ E j then 1 else 0 := rfl
+lemma projectionSymbol_norm_le (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j))
+    (x : Base) (j : ℤ) : ‖projectionSymbol E hE x j‖ ≤ 1 := by
+  by_cases hx : x ∈ E j <;> simp [hx]
+lemma projectionSymbol_star (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) :
+    star (projectionSymbol E hE) = projectionSymbol E hE := by
+  apply Subtype.ext
+  funext x j
+  change star (projectionSymbol E hE x j) = projectionSymbol E hE x j
+  by_cases hx : x ∈ E j <;> simp [hx]
+lemma projectionSymbol_idempotent (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) :
+    projectionSymbol E hE * projectionSymbol E hE = projectionSymbol E hE := by
+  apply Subtype.ext
+  funext x j
+  change projectionSymbol E hE x j * projectionSymbol E hE x j = projectionSymbol E hE x j
+  by_cases hx : x ∈ E j <;> simp [hx]
+
+def diagonalProjection (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  diagonalOperator (projectionSymbol E hE)
+lemma diagonalProjection_ae (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) (f : GlobalHilbert) :
+    ∀ᵐ x ∂baseMeasure, ∀ j, diagonalProjection E hE f x j = if x ∈ E j then f x j else 0 := by
+  filter_upwards [diagonalOperator_coord (projectionSymbol E hE) f] with x hx j
+  change diagonalOperator (projectionSymbol E hE) f x j = _
+  rw [hx,projectionSymbol_apply]
+  split_ifs <;> simp
+lemma diagonalProjection_isStarProjection (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) :
+    IsStarProjection (diagonalProjection E hE) := by
+  constructor
+  · change diagonalOperator (projectionSymbol E hE) * diagonalOperator (projectionSymbol E hE) = _
+    rw [←diagonalOperator_mul,projectionSymbol_idempotent]
+    rfl
+  · change star (diagonalOperator (projectionSymbol E hE)) = diagonalOperator (projectionSymbol E hE)
+    rw [←diagonalOperator_star,projectionSymbol_star]
+lemma diagonalProjection_mul (E F : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j))
+    (hF : ∀ j, MeasurableSet (F j)) :
+    diagonalProjection E hE * diagonalProjection F hF =
+      diagonalProjection (fun j => E j ∩ F j) (fun j => (hE j).inter (hF j)) := by
+  change diagonalOperator _ * diagonalOperator _ = diagonalOperator _
+  rw [←diagonalOperator_mul]
+  congr 1
+  apply Subtype.ext
+  funext x j
+  change projectionSymbol E hE x j * projectionSymbol F hF x j = projectionSymbol _ _ x j
+  by_cases hx : x ∈ E j <;> by_cases hy : x ∈ F j <;> simp [hx,hy]
+lemma diagonalProjection_compl (E : ℤ → Set Base) (hE : ∀ j, MeasurableSet (E j)) :
+    diagonalProjection (fun j => (E j)ᶜ) (fun j => (hE j).compl) = 1-diagonalProjection E hE := by
+  change diagonalRepresentation _ = 1-diagonalRepresentation _
+  rw [←map_one diagonalRepresentation,←map_sub]
+  congr 1
+  apply Subtype.ext
+  funext x j
+  change projectionSymbol _ _ x j = 1-projectionSymbol E hE x j
+  by_cases hx : x ∈ E j <;> simp [hx]
+lemma diagonalProjection_empty : diagonalProjection (fun _ => ∅) (fun _ => MeasurableSet.empty) = 0 := by
+  have h : projectionSymbol (fun _ => ∅) (fun _ => MeasurableSet.empty) = 0 := by
+    apply Subtype.ext; funext x j; simp
+  exact congrArg diagonalOperator h |>.trans diagonalOperator_zero
+lemma diagonalProjection_univ : diagonalProjection (fun _ => Set.univ) (fun _ => MeasurableSet.univ) = 1 := by
+  have h : projectionSymbol (fun _ => Set.univ) (fun _ => MeasurableSet.univ) = 1 := by
+    apply Subtype.ext; funext x j; simp
+  exact congrArg diagonalOperator h |>.trans diagonalOperator_one
+lemma diagonalProjection_ext {E F : ℤ → Set Base} {hE : ∀ j, MeasurableSet (E j)}
+    {hF : ∀ j, MeasurableSet (F j)} (h : ∀ j, E j =ᵐ[baseMeasure] F j) :
+    diagonalProjection E hE = diagonalProjection F hF := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalProjection_ae E hE f,diagonalProjection_ae F hF f,
+    ae_all_iff.mpr h] with x hx hy he
+  ext j
+  rw [hx,hy]
+  have hh : (x ∈ E j) = (x ∈ F j) := he j
+  simp only [hh]
+lemma diagonalProjection_nonzero {E : ℤ → Set Base} {hE : ∀ j, MeasurableSet (E j)}
+    (j : ℤ) (hj : baseMeasure (E j) ≠ 0) : diagonalProjection E hE ≠ 0 := by
+  intro he
+  apply hj
+  apply measure_eq_zero_iff_ae_notMem.mpr
+  filter_upwards [diagonalProjection_ae E hE (constantBasis j),constantBasis_ae j,
+    Lp.coeFn_zero Fiber 2 baseMeasure] with x hx hb hz
+  intro hxE
+  have h := hx j
+  rw [he] at h
+  change (0 : GlobalHilbert) x j = _ at h
+  rw [hz,hb] at h
+  simp [hxE] at h
+
+
+lemma explicitBeta_le_one (x : Base) (j : ℤ) : explicitBeta x j ≤ 1 :=
+  (explicitBeta_le x j).trans (Real.exp_le_one_iff.mpr (by norm_num))
+
+def levelProjection (n : ℤ) (t : ℝ) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  diagonalProjection (fun j => {x | explicitBeta x (j+n) = t})
+    (fun j => measurableSet_eq_fun (measurable_explicitBeta (j+n)) measurable_const)
+
+lemma peak_nonneg {b t : ℝ} (hb₀ : 0 ≤ b) (hb₁ : b ≤ 1) (ht₀ : 0 ≤ t) (ht₁ : t ≤ 1) :
+    0 ≤ 1-(b-t)^2 := by
+  have h₁ : 0 ≤ (1-(b-t))*(1+(b-t)) := mul_nonneg (by linarith) (by linarith)
+  nlinarith
+lemma peak_le_one (b t : ℝ) : 1-(b-t)^2 ≤ 1 := by nlinarith [sq_nonneg (b-t)]
+lemma peak_lt_one {b t : ℝ} (h : b ≠ t) : 1-(b-t)^2 < 1 := by
+  have h' : 0 < (b-t)^2 := sq_pos_of_ne_zero (sub_ne_zero.mpr h)
+  linarith
+
+def peakSymbol (n : ℤ) (t : ℝ) : DiagonalSymbol := 1-(betaSymbol n - (t:ℂ) • 1)^2
+@[simp] lemma peakSymbol_apply (n : ℤ) (t : ℝ) (x : Base) (j : ℤ) :
+    peakSymbol n t x j = ((1-(explicitBeta x (j+n)-t)^2:ℝ):ℂ) := by
+  simp [peakSymbol,Complex.ofReal_sub,Complex.ofReal_pow]
+lemma peakSymbol_bound (n : ℤ) {t : ℝ} (ht₀ : 0 ≤ t) (ht₁ : t ≤ 1) (x : Base) (j : ℤ) :
+    ‖peakSymbol n t x j‖ ≤ 1 := by
+  rw [peakSymbol_apply,Complex.norm_real,Real.norm_of_nonneg
+    (peak_nonneg (explicitBeta_pos _ _).le (explicitBeta_le_one _ _) ht₀ ht₁)]
+  exact peak_le_one _ _
+lemma peakSymbol_powers_tendsto (n : ℤ) {t : ℝ} (ht₀ : 0 ≤ t) (ht₁ : t ≤ 1)
+    (x : Base) (j : ℤ) :
+    Tendsto (fun k : ℕ => (peakSymbol n t ^k) x j) atTop
+      (𝓝 (if explicitBeta x (j+n)=t then (1:ℂ) else 0)) := by
+  simp only [DiagonalSymbol.pow_apply,peakSymbol_apply]
+  by_cases he : explicitBeta x (j+n)=t
+  · simp [he]
+  · simp only [he,↓reduceIte]
+    apply tendsto_pow_atTop_nhds_zero_of_norm_lt_one
+    rw [Complex.norm_real,Real.norm_of_nonneg
+      (peak_nonneg (explicitBeta_pos _ _).le (explicitBeta_le_one _ _) ht₀ ht₁)]
+    exact peak_lt_one he
+lemma levelProjection_mem {A : StarSubalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert)}
+    (hA : StronglyClosed A) (n : ℤ) {t : ℝ} (ht₀ : 0 ≤ t) (ht₁ : t ≤ 1)
+    (hn : polarDiagonal n ∈ A) : levelProjection n t ∈ A := by
+  have hq : diagonalOperator (peakSymbol n t) ∈ A := by
+    change diagonalRepresentation (1-(betaSymbol n - (t:ℂ) • 1)^2) ∈ A
+    rw [map_sub,map_one,map_pow,map_sub,map_smul,map_one]
+    exact A.sub_mem A.one_mem (A.pow_mem (A.sub_mem hn (A.smul_mem A.one_mem _)) _)
+  apply hA.mem_of_tendsto (l:=atTop) (T:=fun k : ℕ => diagonalOperator (peakSymbol n t ^k))
+  · exact Eventually.of_forall fun k => by
+      change diagonalRepresentation (peakSymbol n t ^k) ∈ A
+      rw [map_pow]
+      exact A.pow_mem hq _
+  · intro f
+    apply diagonalOperator_tendsto (C:=1) _ _ zero_le_one
+    · intro k x j
+      rw [DiagonalSymbol.pow_apply,norm_pow]
+      exact pow_le_one₀ (norm_nonneg _) (peakSymbol_bound n ht₀ ht₁ x j)
+    · exact projectionSymbol_norm_le _ _
+    · exact Eventually.of_forall fun x j => by
+        simpa using peakSymbol_powers_tendsto n ht₀ ht₁ x j
+
+
+
+def baseProjection (E : Set Base) (hE : MeasurableSet E) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  diagonalProjection (fun _ => E) (fun _ => hE)
+lemma baseProjection_ae (E : Set Base) (hE : MeasurableSet E) (f : GlobalHilbert) :
+    baseProjection E hE f =ᵐ[baseMeasure] E.indicator f := by
+  filter_upwards [diagonalProjection_ae (fun _ => E) (fun _ => hE) f] with x hx
+  ext j
+  by_cases he : x ∈ E <;> simpa [baseProjection,he] using hx j
+lemma baseProjection_mem_full (E : Set Base) (hE : MeasurableSet E) :
+    baseProjection E hE ∈ fullMultiplierAlgebra := ⟨projectionSymbol _ _,rfl⟩
+lemma diagonal_commute (a b : DiagonalSymbol) :
+    diagonalOperator a * diagonalOperator b = diagonalOperator b * diagonalOperator a := by
+  rw [←diagonalOperator_mul,←diagonalOperator_mul,mul_comm]
+lemma fullMultiplier_commute {A B : GlobalHilbert →L[ℂ] GlobalHilbert}
+    (hA : A ∈ fullMultiplierAlgebra) (hB : B ∈ fullMultiplierAlgebra) : A*B=B*A := by
+  obtain ⟨a,rfl⟩ := hA
+  obtain ⟨b,rfl⟩ := hB
+  exact diagonal_commute a b
+lemma baseProjection_constant (E : Set Base) (hE : MeasurableSet E) (v : Fiber) :
+    baseProjection E hE (Lp.const 2 baseMeasure v) =
+      indicatorConstLp 2 hE (measure_ne_top baseMeasure E) v := by
+  apply Lp.ext
+  filter_upwards [baseProjection_ae E hE (Lp.const 2 baseMeasure v),Lp.coeFn_const 2 baseMeasure v,
+    (indicatorConstLp_coeFn (p:=2) (hs:=hE) (hμs:=measure_ne_top baseMeasure E) (c:=v))] with x hx hv hi
+  rw [hx,hi]
+  by_cases he : x ∈ E <;> simp [he]
+lemma L2_norm_sq (f : GlobalHilbert) : ‖f‖^2 = ∫ x, ‖f x‖^2 ∂baseMeasure := by
+  rw [L2_norm_eq_sqrt,Real.sq_sqrt (integral_nonneg fun _ => sq_nonneg _)]
+lemma baseProjection_norm_sq (E : Set Base) (hE : MeasurableSet E) (f : GlobalHilbert) :
+    ‖baseProjection E hE f‖^2 = ∫ x in E, ‖f x‖^2 ∂baseMeasure := by
+  rw [L2_norm_sq,←integral_indicator hE]
+  apply integral_congr_ae
+  filter_upwards [baseProjection_ae E hE f] with x hx
+  rw [hx]
+  by_cases he : x ∈ E <;> simp [he]
+lemma local_operator_energy_bound (T : GlobalHilbert →L[ℂ] GlobalHilbert)
+    (hT : ∀ E (hE : MeasurableSet E), baseProjection E hE * T = T * baseProjection E hE)
+    (f : GlobalHilbert) : ∀ᵐ x ∂baseMeasure, ‖T f x‖^2 ≤ ‖T‖^2 * ‖f x‖^2 := by
+  have hI (g : GlobalHilbert) : Integrable (fun x : Base => ‖g x‖^2) baseMeasure :=
+    (Lp.memLp g).integrable_norm_pow (by norm_num : (2:ℕ) ≠ 0)
+  apply ae_le_of_forall_setIntegral_le (μ:=baseMeasure) (hI (T f)) ((hI f).const_mul (‖T‖^2))
+  intro E hE _
+  rw [←baseProjection_norm_sq E hE,integral_const_mul,←baseProjection_norm_sq E hE]
+  have he : baseProjection E hE (T f) = T (baseProjection E hE f) := DFunLike.congr_fun (hT E hE) f
+  rw [he]
+  simpa only [mul_pow] using pow_le_pow_left₀ (norm_nonneg _) (T.le_opNorm (baseProjection E hE f)) 2
+
+lemma sliceProjection_diagonal (j : ℤ) : sliceProjection j =
+    diagonalProjection (fun k => if k=j then Set.univ else ∅)
+      (fun k => by split_ifs <;> measurability) := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [sliceProjection_ae j f,diagonalProjection_ae (fun k => if k=j then Set.univ else ∅)
+      (fun k => by split_ifs <;> measurability) f] with x hx hy
+  ext k
+  rw [hx,hy]
+  by_cases he : k=j <;> simp [he,lp.single_apply]
+lemma sliceProjection_mem_full (j : ℤ) : sliceProjection j ∈ fullMultiplierAlgebra := by
+  rw [sliceProjection_diagonal]
+  exact ⟨projectionSymbol _ _,rfl⟩
+
+
+def columnSymbol (T : GlobalHilbert →L[ℂ] GlobalHilbert) : DiagonalSymbol :=
+  ⟨fun x j => if ‖T (constantBasis j) x j‖ ≤ ‖T‖ then T (constantBasis j) x j else 0,
+    ⟨fun j => by
+      have hm : Measurable (fun x => T (constantBasis j) x j) :=
+        ((lp.evalCLM ℂ (fun _ : ℤ => ℂ) 2 j).continuous.comp_stronglyMeasurable
+          (Lp.stronglyMeasurable (T (constantBasis j)))).measurable
+      exact hm.ite (measurableSet_le hm.norm measurable_const) measurable_const,
+      ‖T‖,norm_nonneg T,fun x j => by dsimp only; split_ifs with h <;> simp_all⟩⟩
+lemma columnSymbol_ae (T : GlobalHilbert →L[ℂ] GlobalHilbert)
+    (hT : ∀ E (hE : MeasurableSet E), baseProjection E hE * T = T * baseProjection E hE)
+    (j : ℤ) : ∀ᵐ x ∂baseMeasure, columnSymbol T x j = T (constantBasis j) x j := by
+  filter_upwards [local_operator_energy_bound T hT (constantBasis j),constantBasis_ae j] with x hx hj
+  have hh : ‖T (constantBasis j) x‖ ≤ ‖T‖ := by
+    have h₁ : ‖constantBasis j x‖=1 := by rw [hj]; simp
+    rw [h₁] at hx
+    nlinarith [norm_nonneg (T (constantBasis j) x),norm_nonneg T]
+  have hc : ‖T (constantBasis j) x j‖ ≤ ‖T‖ := (lp.norm_apply_le_norm (by norm_num : (2:ENNReal) ≠ 0) _ j).trans hh
+  exact ite_eq_left hc
+
+lemma columnSymbol_basis (T : GlobalHilbert →L[ℂ] GlobalHilbert)
+    (hT : ∀ E (hE : MeasurableSet E), baseProjection E hE * T = T * baseProjection E hE)
+    (hS : ∀ j, sliceProjection j * T = T * sliceProjection j) (j : ℤ) :
+    diagonalOperator (columnSymbol T) (constantBasis j) = T (constantBasis j) := by
+  have he : sliceProjection j (T (constantBasis j)) = T (constantBasis j) := by
+    rw [show sliceProjection j (T (constantBasis j)) = T (sliceProjection j (constantBasis j)) from DFunLike.congr_fun (hS j) _]
+    simp [sliceProjection_constantBasis]
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord (columnSymbol T) (constantBasis j),constantBasis_ae j,
+    columnSymbol_ae T hT j,sliceProjection_ae j (T (constantBasis j))] with x hx hj hc hs
+  rw [he] at hs
+  ext k
+  rw [hx,hj,hs]
+  by_cases hk : k=j
+  · subst k; simp [hc]
+  · simp [lp.single_apply,hk]
+
+lemma operators_equal_of_constantBasis {T D : GlobalHilbert →L[ℂ] GlobalHilbert}
+    (hc : ∀ j, T (constantBasis j)=D (constantBasis j))
+    (hT : ∀ E (hE : MeasurableSet E), baseProjection E hE*T=T*baseProjection E hE)
+    (hD : ∀ E (hE : MeasurableSet E), baseProjection E hE*D=D*baseProjection E hE) : T=D := by
+  have hconst (v : Fiber) : T (Lp.const 2 baseMeasure v)=D (Lp.const 2 baseMeasure v) := by
+    let L := (Lp.constL 2 baseMeasure ℂ : Fiber →L[ℂ] GlobalHilbert)
+    have h₁ := (lp.hasSum_single (by norm_num : (2:ENNReal) ≠ ∞) v).map (T.comp L).toAddMonoidHom (T.comp L).continuous
+    have h₂ := (lp.hasSum_single (by norm_num : (2:ENNReal) ≠ ∞) v).map (D.comp L).toAddMonoidHom (D.comp L).continuous
+    have hh (j : ℤ) : (T.comp L) (lp.single 2 j (v j)) = (D.comp L) (lp.single 2 j (v j)) := by
+      have he : (lp.single 2 j (v j) : Fiber) = (v j) • lp.single 2 j (1:ℂ) := by
+        rw [←lp.single_smul]; simp
+      rw [he,map_smul,map_smul]
+      exact congrArg (fun w : GlobalHilbert => v j • w) (hc j)
+    exact h₁.unique (h₂.congr_fun hh)
+  ext1 f
+  apply Lp.induction (by norm_num : (2:ENNReal) ≠ ∞) (fun f : GlobalHilbert => T f=D f) (f:=f)
+  · intro v E hE hfin
+    rw [Lp.simpleFunc.coe_indicatorConst,←baseProjection_constant E hE v]
+    have heT := DFunLike.congr_fun (hT E hE) (Lp.const 2 baseMeasure v)
+    have heD := DFunLike.congr_fun (hD E hE) (Lp.const 2 baseMeasure v)
+    change baseProjection E hE (T _) = T (baseProjection E hE _) at heT
+    change baseProjection E hE (D _) = D (baseProjection E hE _) at heD
+    rw [←heT,←heD,hconst]
+  · intro f g hf hg _ h₁ h₂
+    simp only [map_add,h₁,h₂]
+  · exact isClosed_eq T.continuous D.continuous
+
+lemma fullMultiplier_centralizer_eq : StarSubalgebra.centralizer ℂ (fullMultiplierAlgebra : Set _) =
+    fullMultiplierAlgebra := by
+  apply le_antisymm
+  · intro T hT
+    have hcomm {P : GlobalHilbert →L[ℂ] GlobalHilbert} (hP : P ∈ fullMultiplierAlgebra) : P*T=T*P :=
+      ((StarSubalgebra.mem_centralizer_iff ℂ).mp hT P hP).1
+    have hbase : ∀ E (hE : MeasurableSet E), baseProjection E hE*T=T*baseProjection E hE :=
+      fun E hE => hcomm (baseProjection_mem_full E hE)
+    refine ⟨columnSymbol T, ?_⟩
+    apply operators_equal_of_constantBasis (columnSymbol_basis T hbase (fun j => hcomm (sliceProjection_mem_full j)))
+    · intro E hE
+      exact diagonal_commute _ _
+    · exact hbase
+  · intro T hT
+    apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+    intro P hP
+    exact ⟨fullMultiplier_commute hP hT,fullMultiplier_commute (fullMultiplierAlgebra.star_mem' hP) hT⟩
+lemma fullMultiplier_stronglyClosed : StronglyClosed fullMultiplierAlgebra := by
+  rw [←fullMultiplier_centralizer_eq]
+  exact strong_centralizer_closed _
+
+lemma levelProjection_mem_all {A : StarSubalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert)}
+    (hA : StronglyClosed A) (n : ℤ) (t : ℝ) (hn : polarDiagonal n ∈ A) : levelProjection n t ∈ A := by
+  by_cases ht : 0 ≤ t ∧ t ≤ 1
+  · exact levelProjection_mem hA n ht.1 ht.2 hn
+  have he : levelProjection n t = 0 := by
+    unfold levelProjection
+    rw [←diagonalProjection_empty]
+    apply diagonalProjection_ext
+    intro j
+    apply EventuallyEq.of_eq
+    ext x
+    change (explicitBeta x (j+n)=t) ↔ False
+    constructor
+    · intro hx
+      apply ht
+      rw [←hx]
+      exact ⟨(explicitBeta_pos _ _).le,explicitBeta_le_one _ _⟩
+    · exact False.elim
+  rw [he]
+  exact A.zero_mem
+
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/PolarFactors.lean

@@ -0,0 +1,169 @@
+import OAI.Analysis.BackwardIntertwiners.SpectralProjections
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+def coordinateShift (n : ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  (fiberReindex (Equiv.addRight (-n))).toLinearIsometry.toContinuousLinearMap.compLpL 2 baseMeasure
+lemma coordinateShift_ae (n : ℤ) (f : GlobalHilbert) :
+    ∀ᵐ x ∂baseMeasure, ∀ j, coordinateShift n f x j = f x (j-n) := by
+  filter_upwards [ContinuousLinearMap.coeFn_compLpL
+    (fiberReindex (Equiv.addRight (-n))).toLinearIsometry.toContinuousLinearMap f] with x hx j
+  change coordinateShift n f x = fiberReindex (Equiv.addRight (-n)) (f x) at hx
+  rw [hx]
+  rfl
+lemma coordinateShift_zero : coordinateShift 0 = 1 := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [coordinateShift_ae 0 f] with x hx
+  ext j
+  simpa using hx j
+lemma coordinateShift_add (m n : ℤ) : coordinateShift (m+n) = coordinateShift m * coordinateShift n := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [coordinateShift_ae (m+n) f,coordinateShift_ae m (coordinateShift n f),
+    coordinateShift_ae n f] with x hmn hm hn
+  ext j
+  change coordinateShift (m+n) f x j = coordinateShift m (coordinateShift n f) x j
+  rw [hmn,hm,hn]
+  exact congrArg (fun k : ℤ => f x k) (by omega)
+lemma coordinateShift_norm_le (n : ℤ) (f : GlobalHilbert) : ‖coordinateShift n f‖ ≤ ‖f‖ := by
+  apply Lp.norm_le_norm_of_ae_le
+  filter_upwards [ContinuousLinearMap.coeFn_compLpL
+    (fiberReindex (Equiv.addRight (-n))).toLinearIsometry.toContinuousLinearMap f] with x hx
+  change coordinateShift n f x = fiberReindex (Equiv.addRight (-n)) (f x) at hx
+  rw [hx]
+  exact le_of_eq ((fiberReindex _).norm_map _)
+lemma coordinateShift_norm (n : ℤ) (f : GlobalHilbert) : ‖coordinateShift n f‖ = ‖f‖ := by
+  apply le_antisymm (coordinateShift_norm_le n f)
+  have h : coordinateShift (-n) (coordinateShift n f) = f := by
+    have hh := congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T f) (coordinateShift_add (-n) n)
+    simpa only [neg_add_cancel,coordinateShift_zero,one_apply_eq_self,mul_apply_eq_comp] using hh.symm
+  have hn := coordinateShift_norm_le (-n) (coordinateShift n f)
+  rwa [h] at hn
+
+
+def shiftIsometry (n : ℤ) : GlobalHilbert ≃ₗᵢ[ℂ] GlobalHilbert where
+  toFun := coordinateShift n
+  invFun := coordinateShift (-n)
+  map_add' := (coordinateShift n).map_add
+  map_smul' := (coordinateShift n).map_smul
+  left_inv f := by
+    have h := congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T f) (coordinateShift_add (-n) n)
+    simpa only [neg_add_cancel,coordinateShift_zero,one_apply_eq_self,mul_apply_eq_comp] using h.symm
+  right_inv f := by
+    have h := congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T f) (coordinateShift_add n (-n))
+    simpa only [add_neg_cancel,coordinateShift_zero,one_apply_eq_self,mul_apply_eq_comp] using h.symm
+  norm_map' := coordinateShift_norm n
+lemma coordinateShift_star (n : ℤ) : star (coordinateShift n) = coordinateShift (-n) := by
+  change (coordinateShift n).adjoint = _
+  exact (ContinuousLinearMap.eq_adjoint_iff _ _).mpr (by
+    intro f g
+    change inner ℂ (shiftIsometry (-n) f) g = inner ℂ f (shiftIsometry n g)
+    have h := (shiftIsometry n).inner_map_map (shiftIsometry (-n) f) g
+    have he : shiftIsometry n (shiftIsometry (-n) f) = f := (shiftIsometry n).apply_symm_apply f
+    rw [he] at h
+    exact h.symm) |>.symm
+
+def shiftUnit : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ where
+  val := coordinateShift 1
+  inv := coordinateShift (-1)
+  val_inv := by rw [←coordinateShift_add]; norm_num [coordinateShift_zero]
+  inv_val := by rw [←coordinateShift_add]; norm_num [coordinateShift_zero]
+lemma shiftUnit_zpow (n : ℤ) : ((shiftUnit^n : (GlobalHilbert →L[ℂ] GlobalHilbert)ˣ) : GlobalHilbert →L[ℂ] GlobalHilbert) = coordinateShift n := by
+  induction n using Int.induction_on with
+  | zero => simp [coordinateShift_zero]
+  | succ n ih => rw [zpow_add_one,Units.val_mul,ih]; exact (coordinateShift_add _ _).symm
+  | pred n ih => rw [zpow_sub_one,Units.val_mul,ih]; exact (coordinateShift_add _ _).symm
+
+lemma forward_polar_factor : forwardOperator = coordinateShift 1 * polarDiagonal 0 := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [forwardOperator_ae f,coordinateShift_ae 1 (polarDiagonal 0 f),polarDiagonal_ae 0 f] with x hs hu hd
+  ext j
+  change forwardOperator f x j = coordinateShift 1 (polarDiagonal 0 f) x j
+  rw [hs,forwardFiber_apply,hu,hd,add_zero]
+lemma polarDiagonal_conjugate (n : ℤ) :
+    coordinateShift (-n) * polarDiagonal 0 * coordinateShift n = polarDiagonal n := by
+  ext1 f
+  apply Lp.ext
+  filter_upwards [coordinateShift_ae (-n) (polarDiagonal 0 (coordinateShift n f)),
+    polarDiagonal_ae 0 (coordinateShift n f),coordinateShift_ae n f,polarDiagonal_ae n f] with x hu hd hv ha
+  ext j
+  change coordinateShift (-n) (polarDiagonal 0 (coordinateShift n f)) x j = polarDiagonal n f x j
+  rw [hu,hd,hv,ha]
+  simp only [sub_neg_eq_add,add_zero,add_sub_cancel_right]
+
+def betaRootSymbol : DiagonalSymbol :=
+  ⟨fun x j => (Real.sqrt (explicitBeta x j):ℂ),
+    ⟨fun j => Complex.continuous_ofReal.measurable.comp (Real.continuous_sqrt.measurable.comp (measurable_explicitBeta j)),
+      1, zero_le_one, fun x j => by
+        simp only [Complex.norm_real,Real.norm_of_nonneg (Real.sqrt_nonneg _)]
+        apply Real.sqrt_le_one.mpr
+        exact (explicitBeta_le x j).trans (Real.exp_le_one_iff.mpr (by norm_num))⟩⟩
+lemma betaRootSymbol_star : star betaRootSymbol = betaRootSymbol := by
+  apply Subtype.ext
+  funext x j
+  exact Complex.conj_ofReal _
+lemma betaRootSymbol_sq : betaRootSymbol * betaRootSymbol = betaSymbol 0 := by
+  apply Subtype.ext
+  funext x j
+  change (Real.sqrt (explicitBeta x j):ℂ) * (Real.sqrt (explicitBeta x j):ℂ) = (explicitBeta x (j+0):ℂ)
+  rw [add_zero,←Complex.ofReal_mul,Real.mul_self_sqrt (explicitBeta_pos _ _).le]
+lemma polarDiagonal_nonneg : 0 ≤ polarDiagonal 0 := by
+  have h := star_mul_self_nonneg (diagonalOperator betaRootSymbol)
+  rwa [←diagonalOperator_star,betaRootSymbol_star,←diagonalOperator_mul,betaRootSymbol_sq] at h
+local instance realOperatorTower : IsScalarTower ℝ (GlobalHilbert →L[ℂ] GlobalHilbert) (GlobalHilbert →L[ℂ] GlobalHilbert) where
+  smul_assoc scalar first second := by ext vector; rfl
+local instance realOperatorCommute : SMulCommClass ℝ (GlobalHilbert →L[ℂ] GlobalHilbert) (GlobalHilbert →L[ℂ] GlobalHilbert) where
+  smul_comm scalar first second := by
+    apply ContinuousLinearMap.ext
+    intro vector
+    exact (first.map_smul_of_tower scalar (second vector)).symm
+local instance complexNormalCalculus : ContinuousFunctionalCalculus ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) IsStarNormal :=
+  IsStarNormal.instContinuousFunctionalCalculus
+local instance complexClosedCalculus : NonUnitalClosedEmbeddingContinuousFunctionalCalculus ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) IsStarNormal :=
+  IsStarNormal.instNonUnitalContinuousFunctionalCalculus
+local instance realSelfAdjointCalculus : NonUnitalContinuousFunctionalCalculus ℝ (GlobalHilbert →L[ℂ] GlobalHilbert) IsSelfAdjoint :=
+  IsSelfAdjoint.instNonUnitalContinuousFunctionalCalculus (A := GlobalHilbert →L[ℂ] GlobalHilbert)
+lemma polar_modulus : CFC.sqrt (star forwardOperator * forwardOperator) = polarDiagonal 0 := by
+  rw [forward_polar_factor,star_mul,coordinateShift_star,mul_assoc,
+    ←mul_assoc (coordinateShift (-1)) (coordinateShift 1),←coordinateShift_add]
+  norm_num only [Int.reduceNeg,Int.reduceAdd,coordinateShift_zero,one_mul]
+  rw [(polarDiagonal_selfAdjoint 0).star_eq]
+  exact CFC.sqrt_mul_self _ polarDiagonal_nonneg
+lemma polarDiagonal_injective : Function.Injective (polarDiagonal 0) := by
+  intro f g he
+  apply Lp.ext
+  filter_upwards [polarDiagonal_ae 0 f,polarDiagonal_ae 0 g] with x hf hg
+  ext j
+  have h := congrArg (fun v : GlobalHilbert => v x j) he
+  rw [hf,hg] at h
+  exact mul_left_cancel₀ (by exact_mod_cast (explicitBeta_pos x (j+0)).ne') h
+lemma polarDiagonal_denseRange : DenseRange (polarDiagonal 0) := by
+  have hk : (polarDiagonal 0).ker = ⊥ := LinearMap.ker_eq_bot.mpr polarDiagonal_injective
+  have hadj : (polarDiagonal 0).adjoint = polarDiagonal 0 := (polarDiagonal_selfAdjoint 0).star_eq
+  have hc : (polarDiagonal 0).range.topologicalClosure = ⊤ := by
+    rw [←Submodule.orthogonal_orthogonal_eq_closure,ContinuousLinearMap.orthogonal_range,hadj,hk,Submodule.bot_orthogonal_eq_top]
+  intro v
+  change v ∈ (polarDiagonal 0).range.topologicalClosure
+  rw [hc]
+  trivial
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/ProductSymbols.lean

@@ -0,0 +1,111 @@
+import OAI.Analysis.BackwardIntertwiners.AtomicAlgebras
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+attribute [local instance] realOperatorTower realOperatorCommute complexNormalCalculus complexClosedCalculus realSelfAdjointCalculus
+
+open InnerProductSpace ContinuousLinearMap
+
+lemma linfty_ae_norm_le {X : Type*} [MeasurableSpace X] {μ : Measure X} (g : Lp ℂ ∞ μ) :
+    ∀ᵐ z ∂μ, ‖g z‖ ≤ ‖g‖ := by
+  filter_upwards [enorm_ae_le_eLpNormEssSup g μ] with z hz
+  have hg : eLpNormEssSup g μ ≠ ∞ := by
+    simpa only [eLpNorm_exponent_top (Lp.aestronglyMeasurable g)] using Lp.eLpNorm_ne_top g
+  have hh := ENNReal.toReal_mono hg hz
+  simpa only [Lp.norm_def,eLpNorm_exponent_top (Lp.aestronglyMeasurable g), toReal_enorm] using hh
+
+lemma ae_prod_count_iff {X : Type*} [MeasurableSpace X] {μ : Measure X}
+    {p : X × ℤ → Prop} (hp : MeasurableSet {z | p z}) :
+    (∀ᵐ z ∂μ.prod Measure.count, p z) ↔ ∀ᵐ x ∂μ, ∀ j : ℤ, p (x,j) := by
+  rw [Measure.ae_prod_iff_ae_ae hp]
+  simp_rw [Measure.ae_count_iff]
+
+
+
+abbrev productMeasure : Measure (Base × ℤ) := baseMeasure.prod Measure.count
+
+def IsProductMultiplier (T : GlobalHilbert →L[ℂ] GlobalHilbert) : Prop :=
+  ∃ g : Lp ℂ ∞ productMeasure, ∀ f : GlobalHilbert,
+    ∀ᵐ x ∂baseMeasure, ∀ j : ℤ, T f x j = g (x,j) * f x j
+
+lemma DiagonalSymbol.product_measurable (a : DiagonalSymbol) :
+    Measurable (fun z : Base × ℤ => a z.1 z.2) :=
+  measurable_from_prod_countable_left a.measurable
+lemma DiagonalSymbol.product_memLp (a : DiagonalSymbol) :
+    MemLp (fun z : Base × ℤ => a z.1 z.2) ∞ productMeasure :=
+  memLp_top_of_bound a.product_measurable.aestronglyMeasurable a.bound
+    (Eventually.of_forall fun z => a.norm_le_bound z.1 z.2)
+lemma diagonalOperator_isProductMultiplier (a : DiagonalSymbol) :
+    IsProductMultiplier (diagonalOperator a) := by
+  let g : Lp ℂ ∞ productMeasure := a.product_memLp.toLp (fun z : Base × ℤ => a z.1 z.2)
+  have hg : ∀ᵐ x ∂baseMeasure, ∀ j : ℤ, g (x,j) = a x j := by
+    have hh := Measure.ae_ae_of_ae_prod (MemLp.coeFn_toLp a.product_memLp)
+    simpa only [Measure.ae_count_iff] using hh
+  refine ⟨g,fun f => ?_⟩
+  filter_upwards [diagonalOperator_coord a f,hg] with x hx hgx j
+  rw [hx,hgx]
+
+def productBoundedSymbol (g : Lp ℂ ∞ productMeasure) : DiagonalSymbol :=
+  ⟨fun x j => if ‖g (x,j)‖ ≤ ‖g‖ then g (x,j) else 0,
+    (by
+      refine ⟨?_,‖g‖,norm_nonneg _,?_⟩
+      · intro j
+        have hm : Measurable (fun x : Base => g (x,j)) :=
+          (Lp.stronglyMeasurable g).measurable.comp (measurable_id.prodMk measurable_const)
+        exact Measurable.ite (measurableSet_le hm.norm measurable_const) hm measurable_const
+      · intro x j
+        dsimp only
+        split_ifs with h
+        · exact h
+        · simp)⟩
+lemma productBoundedSymbol_ae (g : Lp ℂ ∞ productMeasure) :
+    ∀ᵐ x ∂baseMeasure, ∀ j : ℤ, productBoundedSymbol g x j = g (x,j) := by
+  have hh := Measure.ae_ae_of_ae_prod (linfty_ae_norm_le g)
+  simp_rw [Measure.ae_count_iff] at hh
+  filter_upwards [hh] with x hx j
+  exact ite_eq_left (hx j)
+lemma isProductMultiplier_mem_full {T : GlobalHilbert →L[ℂ] GlobalHilbert}
+    (hT : IsProductMultiplier T) : T ∈ fullMultiplierAlgebra := by
+  obtain ⟨g,hg⟩ := hT
+  refine ⟨productBoundedSymbol g,?_⟩
+  ext1 f
+  apply Lp.ext
+  filter_upwards [diagonalOperator_coord (productBoundedSymbol g) f,
+    productBoundedSymbol_ae g,hg f] with x ha hsym hT
+  ext j
+  change diagonalOperator (productBoundedSymbol g) f x j = T f x j
+  rw [ha,hsym,hT]
+lemma fullMultiplier_mem_iff_productMultiplier (T : GlobalHilbert →L[ℂ] GlobalHilbert) :
+    T ∈ fullMultiplierAlgebra ↔ IsProductMultiplier T := by
+  constructor
+  · rintro ⟨a,rfl⟩
+    exact diagonalOperator_isProductMultiplier a
+  · exact isProductMultiplier_mem_full
+
+
+
+theorem polarAlgebra_mem_iff_productMultiplier (T : GlobalHilbert →L[ℂ] GlobalHilbert) :
+    T ∈ polarAlgebra ↔ IsProductMultiplier T := by
+  rw [polarAlgebra_eq_fullMultiplier]
+  exact fullMultiplier_mem_iff_productMultiplier T
+
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/SpectralProjections.lean

@@ -0,0 +1,369 @@
+import OAI.Analysis.BackwardIntertwiners.PolarDiagonals
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+
+def polarAlgebra : StarSubalgebra ℂ (GlobalHilbert →L[ℂ] GlobalHilbert) := strongGenerated (Set.range polarDiagonal)
+lemma polarDiagonal_mem (n : ℤ) : polarDiagonal n ∈ polarAlgebra := subset_strongGenerated _ ⟨n,rfl⟩
+lemma polarAlgebra_closed : StronglyClosed polarAlgebra := strongGenerated_closed _
+lemma polarAlgebra_le_full : polarAlgebra ≤ fullMultiplierAlgebra := by
+  apply strongGenerated_le fullMultiplier_stronglyClosed
+  rintro _ ⟨n,rfl⟩
+  exact ⟨betaSymbol n,rfl⟩
+lemma polarAlgebra_commutative {A B : GlobalHilbert →L[ℂ] GlobalHilbert}
+    (hA : A ∈ polarAlgebra) (hB : B ∈ polarAlgebra) : A*B=B*A :=
+  fullMultiplier_commute (polarAlgebra_le_full hA) (polarAlgebra_le_full hB)
+
+lemma halfExponent_eq_ten_iff (t : ℕ → ℕ) (k : ℕ) : halfExponent t k=10 ↔ k=0 := by
+  constructor
+  · intro h
+    have hl := halfExponent_lower t k
+    rw [h] at hl
+    have hk : (k:ℝ)=0 := by have := Nat.cast_nonneg (α:=ℝ) k; nlinarith
+    exact_mod_cast hk
+  · rintro rfl
+    simp [halfExponent,residueCorrection]
+lemma explicitBeta_central (x : Base) (j : ℤ) : explicitBeta x j=Real.exp (-10) ↔ j=-1 ∨ j=0 := by
+  have hh (t : ℕ → ℕ) (k : ℕ) : Real.exp (-halfExponent t k)=Real.exp (-10) ↔ k=0 := by
+    rw [Real.exp_eq_exp,neg_inj,halfExponent_eq_ten_iff]
+  cases j with
+  | ofNat k =>
+    change Real.exp (-halfExponent (plusResidue x) k)=Real.exp (-10) ↔ _
+    rw [hh]
+    change k=0 ↔ (k:ℤ) = -1 ∨ (k:ℤ) = 0
+    omega
+  | negSucc k =>
+    change Real.exp (-halfExponent (minusResidue x) k)=Real.exp (-10) ↔ _
+    rw [hh]
+    omega
+lemma sliceProjection_central (r : ℤ) : sliceProjection r=
+    levelProjection (-r-1) (Real.exp (-10)) * levelProjection (-r) (Real.exp (-10)) := by
+  rw [sliceProjection_diagonal,levelProjection,levelProjection,diagonalProjection_mul]
+  apply diagonalProjection_ext
+  intro j
+  apply EventuallyEq.of_eq
+  ext x
+  change (x ∈ if j=r then Set.univ else ∅) ↔
+    (explicitBeta x (j+(-r-1))=Real.exp (-10) ∧ explicitBeta x (j+-r)=Real.exp (-10))
+  simp only [explicitBeta_central]
+  by_cases hj : j=r <;> simp [hj] <;> omega
+lemma sliceProjection_mem_polar (r : ℤ) : sliceProjection r ∈ polarAlgebra := by
+  rw [sliceProjection_central]
+  exact polarAlgebra.mul_mem
+    (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _))
+    (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _))
+
+
+def rectangleProjection (r : ℤ) (E : Set Base) (hE : MeasurableSet E) : GlobalHilbert →L[ℂ] GlobalHilbert :=
+  diagonalProjection (fun j => if j=r then E else ∅) (fun j => by split_ifs; exact hE; exact MeasurableSet.empty)
+lemma rectangleProjection_univ (r : ℤ) : rectangleProjection r Set.univ MeasurableSet.univ=sliceProjection r :=
+  (sliceProjection_diagonal r).symm
+lemma rectangleProjection_empty (r : ℤ) : rectangleProjection r ∅ MeasurableSet.empty=0 := by
+  unfold rectangleProjection
+  convert diagonalProjection_empty using 2
+  ext j x
+  simp
+lemma rectangleProjection_ext {r : ℤ} {E F : Set Base} {hE : MeasurableSet E} {hF : MeasurableSet F}
+    (he : E=ᵐ[baseMeasure] F) : rectangleProjection r E hE=rectangleProjection r F hF := by
+  apply diagonalProjection_ext
+  intro j
+  by_cases hj : j=r <;> simp only [hj,↓reduceIte]
+  · exact he
+  · exact Filter.EventuallyEq.rfl
+lemma rectangleProjection_mul (r : ℤ) (E F : Set Base) (hE : MeasurableSet E) (hF : MeasurableSet F) :
+    rectangleProjection r E hE * rectangleProjection r F hF=rectangleProjection r (E∩F) (hE.inter hF) := by
+  rw [rectangleProjection,rectangleProjection,diagonalProjection_mul]
+  apply diagonalProjection_ext
+  intro j
+  apply EventuallyEq.of_eq
+  by_cases hj : j=r <;> simp only [hj,↓reduceIte,Set.inter_empty]
+lemma rectangleProjection_compl (r : ℤ) (E : Set Base) (hE : MeasurableSet E) :
+    rectangleProjection r Eᶜ hE.compl = sliceProjection r - rectangleProjection r E hE := by
+  rw [sliceProjection_diagonal]
+  change diagonalRepresentation _ = diagonalRepresentation _ - diagonalRepresentation _
+  rw [←map_sub]
+  congr 1
+  apply Subtype.ext
+  funext x j
+  change projectionSymbol _ _ x j = projectionSymbol _ _ x j - projectionSymbol _ _ x j
+  by_cases hj : j=r <;> by_cases he : x∈E <;> simp [hj,he]
+lemma rectangleProjection_union (r : ℤ) (E F : Set Base) (hE : MeasurableSet E) (hF : MeasurableSet F) :
+    rectangleProjection r (E∪F) (hE.union hF) = rectangleProjection r E hE+rectangleProjection r F hF-
+      rectangleProjection r E hE * rectangleProjection r F hF := by
+  change diagonalRepresentation _ = diagonalRepresentation _+diagonalRepresentation _-diagonalRepresentation _*diagonalRepresentation _
+  rw [←map_mul,←map_add,←map_sub]
+  congr 1
+  apply Subtype.ext
+  funext x j
+  change projectionSymbol _ _ x j = projectionSymbol _ _ x j + projectionSymbol _ _ x j - projectionSymbol _ _ x j * projectionSymbol _ _ x j
+  by_cases hj : j=r <;> by_cases he : x∈E <;> by_cases hf : x∈F <;> simp [hj,he,hf]
+
+def blockAnchor (m : ℕ) : ℕ := 8^(m-1)
+lemma blockAnchor_ne_zero (m : ℕ) : blockAnchor m ≠ 0 := pow_ne_zero _ (by norm_num)
+lemma blockAnchor_block {m : ℕ} (hm : 1 ≤ m) : weightBlock (blockAnchor m)=m := by
+  rw [weightBlock,blockAnchor,Nat.log_pow (by norm_num : 1<8)]
+  omega
+def residueEigenvalue (m t : ℕ) : ℝ :=
+  Real.exp (-(10*((blockAnchor m:ℝ)+1)+100*((2^m:ℝ)-2+(t:ℝ))))
+lemma beta_anchor_residue {m : ℕ} (hm : 1 ≤ m) (t : ℕ) (x : Base) :
+    explicitBeta x (blockAnchor m) = residueEigenvalue m t ↔ residue m x=t := by
+  change Real.exp (-halfExponent (plusResidue x) (blockAnchor m))=residueEigenvalue m t ↔ _
+  rw [residueEigenvalue,Real.exp_eq_exp,neg_inj]
+  simp only [halfExponent,residueCorrection,blockAnchor_ne_zero,↓reduceIte,
+    residueScale,blockAnchor_block hm,plusResidue]
+  push_cast
+  constructor
+  · intro h
+    have he : (residue m x:ℝ)=(t:ℝ) := by linarith
+    exact_mod_cast he
+  · intro h
+    rw [h]
+lemma residue_rectangle_spectral {m : ℕ} (hm : 1 ≤ m) (t : ℕ) (r : ℤ) :
+    rectangleProjection r (residueClass m t) (measurableSet_residueClass m t) =
+      sliceProjection r * levelProjection ((blockAnchor m:ℤ)-r) (residueEigenvalue m t) := by
+  rw [sliceProjection_diagonal,levelProjection,diagonalProjection_mul]
+  apply diagonalProjection_ext
+  intro j
+  apply EventuallyEq.of_eq
+  ext x
+  by_cases hj : j=r
+  · subst j
+
+
+    simp only [↓reduceIte,Set.mem_inter_iff,Set.mem_univ,true_and,Set.mem_ofPred_eq]
+    change residue m x=t ↔ explicitBeta x (r+((blockAnchor m:ℤ)-r))=residueEigenvalue m t
+    rw [show r+((blockAnchor m:ℤ)-r)=(blockAnchor m:ℤ) by omega]
+    exact (beta_anchor_residue hm t x).symm
+  · simp [hj]
+lemma residue_rectangle_mem (m t : ℕ) (r : ℤ) :
+    rectangleProjection r (residueClass m t) (measurableSet_residueClass m t) ∈ polarAlgebra := by
+  by_cases hm : m=0
+  · subst m
+    have hz (x : Base) : residue 0 x=0 := by have := residue_lt 0 x; norm_num at this; omega
+    by_cases ht : t=0
+    · have he : residueClass 0 t=Set.univ := by ext x; simp [residueClass,hz,ht]
+      have hr : rectangleProjection r (residueClass 0 t) (measurableSet_residueClass 0 t)=sliceProjection r := by
+        exact (rectangleProjection_ext (EventuallyEq.of_eq he)).trans (rectangleProjection_univ r)
+      rw [hr]
+      exact sliceProjection_mem_polar _
+    · have he : residueClass 0 t=∅ := by ext x; simp [residueClass,hz,Ne.symm ht]
+      have hr : rectangleProjection r (residueClass 0 t) (measurableSet_residueClass 0 t)=0 := by
+        exact (rectangleProjection_ext (EventuallyEq.of_eq he)).trans (rectangleProjection_empty r)
+      rw [hr]
+      exact polarAlgebra.zero_mem
+  · rw [residue_rectangle_spectral (by omega : 1 ≤ m)]
+    exact polarAlgebra.mul_mem (sliceProjection_mem_polar _)
+      (levelProjection_mem_all polarAlgebra_closed _ _ (polarDiagonal_mem _))
+
+lemma borel_le_of_residue_measurable (m : MeasurableSpace (PadicInt 2))
+    (hm : ∀ n t : ℕ, @MeasurableSet (PadicInt 2) m {x | twoResidue n x=t}) :
+    padicBorel ≤ m := by
+  let : MeasurableSpace (PadicInt 2) := padicBorel
+  let R : PadicInt 2 → ℕ → ℕ := fun x n => twoResidue n x
+  have hc : Continuous R := continuous_pi fun n =>
+    continuous_of_discreteTopology.comp (continuous_twoResidue n)
+  have hi : Function.Injective R := by
+    intro x y h
+    apply PadicInt.ext_of_toZModPow.mp
+    intro n
+    apply ZMod.val_injective
+    exact congrFun h n
+  have he : MeasurableEmbedding R := (hc.isClosedEmbedding hi).measurableEmbedding
+  have hr : @Measurable _ _ m inferInstance R := by
+    let : MeasurableSpace (PadicInt 2) := m
+    apply Measurable.of_eval
+    intro n
+    exact measurable_to_countable' (hm n)
+  exact he.comap_eq.symm.le.trans hr.comap_le
+
+lemma rectangleProjection_finiteUnion_mem (r : ℤ) (E : ℕ → Set Base)
+    (hE : ∀ i, MeasurableSet (E i)) (hmem : ∀ i, rectangleProjection r (E i) (hE i) ∈ polarAlgebra)
+    (s : Finset ℕ) : rectangleProjection r (⋃ i ∈ s, E i) (by measurability) ∈ polarAlgebra := by
+  induction s using Finset.induction_on with
+  | empty =>
+    have he : (⋃ i ∈ (∅:Finset ℕ), E i)=∅ := by simp
+    have hp : rectangleProjection r (⋃ i ∈ (∅ : Finset ℕ), E i) (by measurability) =
+        rectangleProjection r ∅ MeasurableSet.empty := rectangleProjection_ext (EventuallyEq.of_eq he)
+    rw [hp, rectangleProjection_empty]
+    exact polarAlgebra.zero_mem
+  | @insert i s hi hs =>
+    have he : (⋃ k ∈ insert i s, E k)=E i ∪ ⋃ k ∈ s,E k := by simp
+    have hp : rectangleProjection r (⋃ k ∈ insert i s, E k) (by measurability) =
+        rectangleProjection r (E i ∪ ⋃ k ∈ s, E k) ((hE i).union (by measurability)) :=
+      rectangleProjection_ext (EventuallyEq.of_eq he)
+    rw [hp,
+      rectangleProjection_union r (E i) (⋃ k∈s,E k) (hE i) (by measurability)]
+    exact polarAlgebra.sub_mem (polarAlgebra.add_mem (hmem i) hs) (polarAlgebra.mul_mem (hmem i) hs)
+
+lemma rectangleProjection_iUnion_mem (r : ℤ) (E : ℕ → Set Base)
+    (hE : ∀ i, MeasurableSet (E i)) (hmem : ∀ i, rectangleProjection r (E i) (hE i) ∈ polarAlgebra) :
+    rectangleProjection r (⋃ i, E i) (MeasurableSet.iUnion hE) ∈ polarAlgebra := by
+  let a (s : Finset ℕ) : DiagonalSymbol := projectionSymbol
+    (fun j => if j=r then ⋃i∈s,E i else ∅) (fun j => by split_ifs <;> measurability)
+  let b : DiagonalSymbol := projectionSymbol
+    (fun j => if j=r then ⋃i,E i else ∅) (fun j => by split_ifs <;> measurability)
+  apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=fun s => diagonalOperator (a s))
+  · exact Eventually.of_forall (rectangleProjection_finiteUnion_mem r E hE hmem)
+  · intro f
+    apply diagonalOperator_tendsto (b:=b) a zero_le_one
+      (fun s => projectionSymbol_norm_le _ _) (projectionSymbol_norm_le _ _)
+    apply Eventually.of_forall
+    intro x j
+    apply tendsto_const_nhds.congr'
+    by_cases hj : j=r
+    · by_cases hx : x ∈ ⋃i,E i
+      · obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hx
+        filter_upwards [eventually_ge_atTop ({i}:Finset ℕ)] with s hs
+        have his : i∈s := Finset.singleton_subset_iff.mp hs
+        have hxs : x∈⋃i∈s,E i := Set.mem_iUnion.mpr ⟨i,Set.mem_iUnion.mpr ⟨his,hi⟩⟩
+        simp [a,b,hj,hx,hxs]
+      · exact Eventually.of_forall (fun s => by
+          have hxs : x ∉ ⋃i∈s,E i := fun h => hx (by
+            obtain ⟨i,hi,hiE⟩ := Set.mem_iUnion.mp h |>.imp (fun i hi => Set.mem_iUnion.mp hi)
+            exact Set.mem_iUnion.mpr ⟨i,hiE⟩)
+          simp [a,b,hj,hx,hxs])
+    · exact Eventually.of_forall (fun s=>by simp [a,b,hj])
+
+
+@[instance_reducible]
+def polarProjectionMeasurableSpace (r : ℤ) : MeasurableSpace Base where
+  MeasurableSet' E := ∃ hE : MeasurableSet E, rectangleProjection r E hE ∈ polarAlgebra
+  measurableSet_empty := ⟨MeasurableSet.empty,by rw [rectangleProjection_empty]; exact polarAlgebra.zero_mem⟩
+  measurableSet_compl E h := by
+    obtain ⟨hE,hm⟩ := h
+    refine ⟨hE.compl,?_⟩
+    rw [rectangleProjection_compl r E hE]
+    exact polarAlgebra.sub_mem (sliceProjection_mem_polar r) hm
+  measurableSet_iUnion E h := by
+    choose hE hm using h
+    exact ⟨MeasurableSet.iUnion hE,rectangleProjection_iUnion_mem r E hE hm⟩
+
+lemma rectangleProjection_borel_mem (r : ℤ) {E : Set (PadicInt 2)} (hE : MeasurableSet E) :
+    rectangleProjection r E (hE.nullMeasurableSet (μ:=baseHaar)) ∈ polarAlgebra := by
+  have hm : padicBorel ≤ polarProjectionMeasurableSpace r :=
+    borel_le_of_residue_measurable _ (fun m t =>
+      ⟨measurableSet_residueClass m t,residue_rectangle_mem m t r⟩)
+  exact (hm E hE).choose_spec
+
+lemma rectangleProjection_mem (r : ℤ) (E : Set Base) (hE : MeasurableSet E) :
+    rectangleProjection r E hE ∈ polarAlgebra := by
+  obtain ⟨F,hsub,hF,he⟩ := (show NullMeasurableSet (show Set (PadicInt 2) from E) baseHaar from hE).exists_measurable_superset_ae_eq
+  have he' : (show Set Base from F)=ᵐ[baseMeasure] E := he
+  rw [←rectangleProjection_ext (hE:=hF.nullMeasurableSet (μ:=baseHaar)) he']
+  exact rectangleProjection_borel_mem r hF
+lemma DiagonalSymbol.sum_apply {ι : Type*} (s : Finset ι) (a : ι → DiagonalSymbol) (x : Base) (j : ℤ) :
+    (∑ i ∈ s, a i) x j = ∑ i ∈ s, a i x j := by
+  induction s using Finset.induction_on with
+  | empty => simp
+  | @insert i s hi hs => simp [Finset.sum_insert,hi,hs]
+
+
+def simpleSliceSymbol (r : ℤ) (f : SimpleFunc Base ℂ) : DiagonalSymbol :=
+  ∑ t ∈ f.range, t • projectionSymbol
+    (fun j => if j=r then f ⁻¹' {t} else ∅)
+    (fun j=>by split_ifs; exact f.measurableSet_fiber t; exact MeasurableSet.empty)
+lemma simpleSliceSymbol_apply (r : ℤ) (f : SimpleFunc Base ℂ) (x : Base) (j : ℤ) :
+    simpleSliceSymbol r f x j=if j=r then f x else 0 := by
+  simp only [simpleSliceSymbol,DiagonalSymbol.sum_apply,DiagonalSymbol.smul_apply,projectionSymbol_apply]
+  by_cases hj : j=r
+  · simp only [hj,↓reduceIte,Set.mem_preimage,Set.mem_singleton_iff,mul_ite,mul_one,mul_zero]
+    rw [Finset.sum_eq_single (f x)]
+    · simp
+    · intro b hb hbx
+      simp [Ne.symm hbx]
+    · exact fun hn => (hn (f.mem_range_self x)).elim
+  · simp [hj]
+lemma simpleSliceSymbol_mem (r : ℤ) (f : SimpleFunc Base ℂ) : diagonalOperator (simpleSliceSymbol r f) ∈ polarAlgebra := by
+  change diagonalRepresentation (∑ t ∈ f.range, _) ∈ polarAlgebra
+  rw [map_sum]
+  apply polarAlgebra.sum_mem
+  intro t ht
+  rw [map_smul]
+  exact polarAlgebra.smul_mem (rectangleProjection_mem r (f ⁻¹' {t}) (f.measurableSet_fiber t)) t
+
+def sliceSymbol (r : ℤ) (a : DiagonalSymbol) : DiagonalSymbol :=
+  a * projectionSymbol (fun j=>if j=r then Set.univ else ∅) (fun j=>by split_ifs <;> measurability)
+lemma sliceSymbol_apply (r : ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) :
+    sliceSymbol r a x j=if j=r then a x r else 0 := by
+  by_cases hj : j=r <;> simp [sliceSymbol,hj]
+lemma sliceSymbol_norm_le (r : ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) :
+    ‖sliceSymbol r a x j‖ ≤ a.bound := by
+  rw [sliceSymbol_apply]
+  split_ifs
+  · exact a.norm_le_bound x r
+  · simpa using a.bound_nonneg
+lemma sliceSymbol_mem (r : ℤ) (a : DiagonalSymbol) : diagonalOperator (sliceSymbol r a) ∈ polarAlgebra := by
+  let f (n : ℕ) : SimpleFunc Base ℂ := SimpleFunc.approxOn (fun x=>a x r) (a.measurable r) Set.univ 0 (Set.mem_univ _) n
+  apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=fun n=>diagonalOperator (simpleSliceSymbol r (f n)))
+  · exact Eventually.of_forall (fun n=>simpleSliceSymbol_mem r (f n))
+  · intro v
+    apply diagonalOperator_tendsto (C:=2*a.bound) _ _ (mul_nonneg (by norm_num) a.bound_nonneg)
+    · intro n x j
+      rw [simpleSliceSymbol_apply]
+      split_ifs
+      · exact (SimpleFunc.norm_approxOn_zero_le (a.measurable r) (Set.mem_univ (0:ℂ)) x n).trans
+          (by linarith [a.norm_le_bound x r])
+      · simpa using mul_nonneg (by norm_num : (0:ℝ) ≤ 2) a.bound_nonneg
+    · intro x j
+      exact (sliceSymbol_norm_le r a x j).trans (by linarith [a.bound_nonneg])
+    · apply Eventually.of_forall
+      intro x j
+      simp only [simpleSliceSymbol_apply,sliceSymbol_apply]
+      by_cases hj : j=r
+      · simp only [hj,↓reduceIte]
+        exact SimpleFunc.tendsto_approxOn (a.measurable r) (Set.mem_univ (0:ℂ)) (by simp)
+      · simp only [hj,↓reduceIte]
+        exact tendsto_const_nhds
+
+lemma finiteSliceSymbol_apply (s : Finset ℤ) (a : DiagonalSymbol) (x : Base) (j : ℤ) :
+    (∑ r ∈ s,sliceSymbol r a) x j=if j∈s then a x j else 0 := by
+  rw [DiagonalSymbol.sum_apply]
+  simp_rw [sliceSymbol_apply]
+  simp
+lemma diagonalOperator_mem_polar (a : DiagonalSymbol) : diagonalOperator a ∈ polarAlgebra := by
+  let T (s : Finset ℤ) : GlobalHilbert →L[ℂ] GlobalHilbert := diagonalOperator (∑ r ∈ s,sliceSymbol r a)
+  apply polarAlgebra_closed.mem_of_tendsto (l:=atTop) (T:=T)
+  · apply Eventually.of_forall
+    intro s
+    change diagonalRepresentation (∑ r ∈ s,sliceSymbol r a) ∈ polarAlgebra
+    rw [map_sum]
+    exact polarAlgebra.sum_mem (fun r _=>sliceSymbol_mem r a)
+  · intro v
+    apply diagonalOperator_tendsto (C:=a.bound) _ _ a.bound_nonneg
+    · intro s x j
+      rw [finiteSliceSymbol_apply]
+      split_ifs
+      · exact a.norm_le_bound x j
+      · simpa using a.bound_nonneg
+    · exact a.norm_le_bound
+    · apply Eventually.of_forall
+      intro x j
+      apply tendsto_const_nhds.congr'
+      filter_upwards [eventually_ge_atTop ({j}:Finset ℤ)] with s hs
+      rw [finiteSliceSymbol_apply,ite_eq_left (Finset.singleton_subset_iff.mp hs)]
+
+
+
+theorem polarAlgebra_eq_fullMultiplier : polarAlgebra=fullMultiplierAlgebra := by
+  apply le_antisymm polarAlgebra_le_full
+  rintro T ⟨a,rfl⟩
+  exact diagonalOperator_mem_polar a
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/StrongClosure.lean

@@ -0,0 +1,208 @@
+import OAI.Analysis.BackwardIntertwiners.DiagonalSymbols
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+open Topology MeasureTheory Set
+open scoped ENNReal
+
+open scoped Classical
+
+lemma L2_norm_eq_sqrt {X E : Type*} [MeasurableSpace X] [NormedAddCommGroup E]
+    {μ : Measure X} (f : Lp E 2 μ) :
+    ‖f‖ = Real.sqrt (∫ x, ‖f x‖^2 ∂μ) := by
+  rw [Lp.norm_def, toReal_eLpNorm,
+    lpNorm_eq_integral_norm_rpow_toReal (by norm_num : (2:ENNReal) ≠ 0)
+      (by norm_num : (2:ENNReal) ≠ ∞) (Lp.aestronglyMeasurable f)]
+  simp [Real.sqrt_eq_rpow]
+
+lemma L2_tendsto_zero_of_dominated {X E ι : Type*} {l : Filter ι} [l.IsCountablyGenerated] [MeasurableSpace X] [NormedAddCommGroup E]
+    {μ : Measure X} (F : ι → Lp E 2 μ) (b : X → ℝ)
+    (hb : Integrable (fun x => b x ^ 2) μ)
+    (hB : ∀ n, ∀ᵐ x ∂μ, ‖F n x‖ ≤ b x)
+    (hlim : ∀ᵐ x ∂μ, Tendsto (fun n => F n x) l (𝓝 0)) :
+    Tendsto F l (𝓝 0) := by
+  apply tendsto_zero_iff_norm_tendsto_zero.mpr
+  have hi : Tendsto (fun n => ∫ x, ‖F n x‖^2 ∂μ) l (𝓝 0) := by
+    simpa using tendsto_integral_filter_of_dominated_convergence (f:=fun _ : X => (0:ℝ))
+      (fun x => b x^2)
+      (Eventually.of_forall fun n => ((Lp.aestronglyMeasurable (F n)).norm.aemeasurable.pow_const 2).aestronglyMeasurable)
+      (Eventually.of_forall fun n => (hB n).mono fun x hx => by
+        rw [Real.norm_of_nonneg (sq_nonneg _)]
+        exact pow_le_pow_left₀ (norm_nonneg _) hx 2) hb
+      (hlim.mono fun x hx => by simpa using hx.norm.pow 2)
+  simpa only [Function.comp_def, Real.sqrt_zero, L2_norm_eq_sqrt] using Real.continuous_sqrt.continuousAt.tendsto.comp hi
+
+lemma fiber_norm_sq (v : Fiber) : ‖v‖^2 = ∑' j, ‖v j‖^2 := by
+  simpa using lp.norm_rpow_eq_tsum (by norm_num : (0:ℝ) < (2:ENNReal).toReal) v
+lemma fiber_tendsto_zero_of_dominated {ι : Type*} {l : Filter ι} (v : ι → Fiber) (b : ℤ → ℝ)
+    (hb : Summable (fun j => b j^2))
+    (hB : ∀ n j, ‖v n j‖ ≤ b j)
+    (hlim : ∀ j, Tendsto (fun n => v n j) l (𝓝 0)) :
+    Tendsto v l (𝓝 0) := by
+  apply tendsto_zero_iff_norm_tendsto_zero.mpr
+  have hi : Tendsto (fun n => ‖v n‖^2) l (𝓝 0) := by
+    simp_rw [fiber_norm_sq]
+    simpa using tendsto_tsum_of_dominated_convergence (g:=fun _ : ℤ => (0:ℝ)) hb
+      (fun j => by simpa using (hlim j).norm.pow 2)
+      (Filter.Eventually.of_forall fun n j => by
+        rw [Real.norm_of_nonneg (sq_nonneg _)]
+        exact pow_le_pow_left₀ (norm_nonneg _) (hB n j) 2)
+  simpa only [Function.comp_def, Real.sqrt_zero, Real.sqrt_sq_eq_abs,abs_of_nonneg (norm_nonneg _)]
+    using Real.continuous_sqrt.continuousAt.tendsto.comp hi
+lemma diagonalFiber_bound (a : DiagonalSymbol) {C : ℝ} (hC : 0 ≤ C)
+    (ha : ∀ x j, ‖a x j‖ ≤ C) (x : Base) (v : Fiber) :
+    ‖diagonalFiber a x v‖ ≤ C*‖v‖ := by
+  calc
+    _ ≤ ‖(C:ℂ) • v‖ := by
+      apply lp.norm_mono (by norm_num : (2:ENNReal) ≠ 0)
+      intro j
+      simp only [diagonalFiber_apply,lp.coeFn_smul,Pi.smul_apply,norm_smul,norm_mul,
+        Complex.norm_real,Real.norm_of_nonneg hC]
+      exact mul_le_mul_of_nonneg_right (ha x j) (norm_nonneg _)
+    _ = C*‖v‖ := by rw [norm_smul,Complex.norm_real,Real.norm_of_nonneg hC]
+
+lemma diagonalFiber_tendsto_zero {ι : Type*} {l : Filter ι} (a : ι → DiagonalSymbol) {C : ℝ}
+    (ha : ∀ n x j, ‖a n x j‖ ≤ C) (x : Base) (v : Fiber)
+    (hlim : ∀ j, Tendsto (fun n => a n x j) l (𝓝 0)) :
+    Tendsto (fun n => diagonalFiber (a n) x v) l (𝓝 0) := by
+  apply fiber_tendsto_zero_of_dominated _ (fun j => C*‖v j‖)
+  · have hv : Summable (fun j => ‖v j‖^2) := by
+      simpa using (lp.memℓp v).summable (by norm_num : (0:ℝ) < (2:ENNReal).toReal)
+    simpa only [mul_pow] using hv.mul_left (C^2)
+  · intro n j
+    rw [diagonalFiber_apply,norm_mul]
+    exact mul_le_mul_of_nonneg_right (ha n x j) (norm_nonneg _)
+  · intro j
+    simpa using (hlim j).mul_const (v j)
+lemma L2_integrable_bound_sq (f : GlobalHilbert) (C : ℝ) :
+    Integrable (fun x => (C*‖f x‖)^2) baseMeasure := by
+  have hf : Integrable (fun x => ‖f x‖^2) baseMeasure :=
+    (Lp.memLp f).integrable_norm_pow (by norm_num : (2:ℕ) ≠ 0)
+  simpa only [mul_pow] using hf.const_mul (C^2)
+lemma diagonalOperator_tendsto_zero {ι : Type*} [Countable ι] {l : Filter ι} [l.IsCountablyGenerated] (a : ι → DiagonalSymbol) {C : ℝ}
+    (hC : 0 ≤ C) (ha : ∀ n x j, ‖a n x j‖ ≤ C)
+    (hlim : ∀ᵐ x ∂baseMeasure, ∀ j, Tendsto (fun n => a n x j) l (𝓝 0))
+    (f : GlobalHilbert) : Tendsto (fun n => diagonalOperator (a n) f) l (𝓝 0) := by
+  apply L2_tendsto_zero_of_dominated _ (fun x => C*‖f x‖) (L2_integrable_bound_sq f C)
+  · intro n
+    filter_upwards [diagonalOperator_ae (a n) f] with x hx
+    rw [hx]
+    exact diagonalFiber_bound _ hC (ha n) _ _
+  · filter_upwards [hlim,ae_all_iff.mpr (fun n => diagonalOperator_ae (a n) f)] with x hx hn
+    have he : (fun n => diagonalOperator (a n) f x) = (fun n => diagonalFiber (a n) x (f x)) := funext hn
+    rw [he]
+    exact diagonalFiber_tendsto_zero a ha x (f x) hx
+lemma diagonalOperator_tendsto {ι : Type*} [Countable ι] {l : Filter ι} [l.IsCountablyGenerated] (a : ι → DiagonalSymbol) (b : DiagonalSymbol)
+    {C : ℝ} (hC : 0 ≤ C) (ha : ∀ n x j, ‖a n x j‖ ≤ C)
+    (hb : ∀ x j, ‖b x j‖ ≤ C)
+    (hlim : ∀ᵐ x ∂baseMeasure, ∀ j, Tendsto (fun n => a n x j) l (𝓝 (b x j)))
+    (f : GlobalHilbert) :
+    Tendsto (fun n => diagonalOperator (a n) f) l (𝓝 (diagonalOperator b f)) := by
+  have hB : ∀ n x j, ‖(a n-b) x j‖ ≤ 2*C := fun n x j =>
+    (norm_sub_le _ _).trans ((add_le_add (ha n x j) (hb x j)).trans_eq (by ring))
+  have hl : ∀ᵐ x ∂baseMeasure, ∀ j, Tendsto (fun n => (a n-b) x j) l (𝓝 0) := by
+    filter_upwards [hlim] with x hx j
+    simpa only [DiagonalSymbol.sub_apply,sub_self] using (hx j).sub_const (b x j)
+  have hh := diagonalOperator_tendsto_zero (fun n => a n-b) (mul_nonneg (by norm_num) hC) hB hl f
+  have he (n : ι) : diagonalOperator (a n-b) f = diagonalOperator (a n) f - diagonalOperator b f :=
+    congrArg (fun T : GlobalHilbert →L[ℂ] GlobalHilbert => T f) (map_sub diagonalRepresentation (a n) b)
+  simp_rw [he] at hh
+  exact tendsto_sub_nhds_zero_iff.mp hh
+
+universe u
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [completeSpace : CompleteSpace H]
+
+@[instance_reducible]
+def strongOperatorTopology : TopologicalSpace (H →L[ℂ] H) :=
+  TopologicalSpace.induced (fun T : H →L[ℂ] H => (fun v : H => T v)) inferInstance
+
+def StronglyClosed (A : StarSubalgebra ℂ (H →L[ℂ] H)) : Prop :=
+  @IsClosed (H →L[ℂ] H) strongOperatorTopology A
+
+omit completeSpace in
+lemma strong_continuous_apply [CompleteSpace H] (v : H) :
+    @Continuous (H →L[ℂ] H) H strongOperatorTopology inferInstance (fun T => T v) := by
+  let := strongOperatorTopology (H:=H)
+  exact (continuous_apply v).comp continuous_induced_dom
+
+lemma StronglyClosed.mem_of_tendsto {A : StarSubalgebra ℂ (H →L[ℂ] H)}
+    (hA : StronglyClosed A) {ι : Type*} {l : Filter ι} [l.NeBot]
+    {T : ι → H →L[ℂ] H} {S : H →L[ℂ] H}
+    (hT : ∀ᶠ i in l, T i ∈ A) (hlim : ∀ v, Tendsto (fun i => T i v) l (𝓝 (S v))) :
+    S ∈ A := by
+  let := strongOperatorTopology (H:=H)
+  refine IsClosed.mem_of_tendsto hA (f:=T) ?_ hT
+  change Tendsto T l (@nhds (H →L[ℂ] H) (TopologicalSpace.induced _ _) S)
+  rw [nhds_induced,Filter.tendsto_comap_iff]
+  exact tendsto_pi_nhds.mpr hlim
+
+
+def strongGenerated (s : Set (H →L[ℂ] H)) : StarSubalgebra ℂ (H →L[ℂ] H) :=
+  sInf {A | StronglyClosed A ∧ s ⊆ A}
+lemma mem_strongGenerated {s : Set (H →L[ℂ] H)} {T : H →L[ℂ] H} :
+    T ∈ strongGenerated s ↔ ∀ A : StarSubalgebra ℂ (H →L[ℂ] H),
+      StronglyClosed A → s ⊆ A → T ∈ A := by
+  simp [strongGenerated,StarSubalgebra.mem_sInf]
+lemma subset_strongGenerated (s : Set (H →L[ℂ] H)) : s ⊆ strongGenerated s := by
+  intro T hT
+  exact mem_strongGenerated.mpr fun _ _ hs => hs hT
+lemma strongGenerated_le {s : Set (H →L[ℂ] H)} {A : StarSubalgebra ℂ (H →L[ℂ] H)}
+    (hA : StronglyClosed A) (hs : s ⊆ A) : strongGenerated s ≤ A :=
+  fun _ hT => mem_strongGenerated.mp hT A hA hs
+lemma strongGenerated_closed (s : Set (H →L[ℂ] H)) : StronglyClosed (strongGenerated s) := by
+  let := strongOperatorTopology (H:=H)
+  have he : (strongGenerated s : Set (H →L[ℂ] H)) =
+      ⋂ A : StarSubalgebra ℂ (H →L[ℂ] H), ⋂ (_ : StronglyClosed A ∧ s ⊆ A), (A : Set _) := by
+    ext T
+    simp [mem_strongGenerated]
+  rw [StronglyClosed,he]
+  exact isClosed_iInter fun A => isClosed_iInter fun h => h.1
+lemma strongGenerated_mono {s t : Set (H →L[ℂ] H)} (hst : s ⊆ t) :
+    strongGenerated s ≤ strongGenerated t :=
+  strongGenerated_le (strongGenerated_closed t) (hst.trans (subset_strongGenerated t))
+
+lemma strong_centralizer_closed (s : Set (H →L[ℂ] H)) :
+    StronglyClosed (StarSubalgebra.centralizer ℂ s) := by
+  let := strongOperatorTopology (H:=H)
+  have he : (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H)) =
+      ⋂ A ∈ s ∪ star s, ⋂ v : H, {T | A (T v) = T (A v)} := by
+    ext T
+    change (∀ A ∈ s ∪ star s, A*T=T*A) ↔ _
+    simp only [mem_iInter,mem_ofPred_eq]
+    exact forall₂_congr fun A hA => ⟨fun h v => DFunLike.congr_fun h v,
+      fun h => ContinuousLinearMap.ext h⟩
+  rw [StronglyClosed,he]
+  exact isClosed_iInter fun A => isClosed_iInter fun _ => isClosed_iInter fun v =>
+    isClosed_eq (A.continuous.comp (strong_continuous_apply v)) (strong_continuous_apply (A v))
+
+
+lemma strongGenerated_commutative {s : Set (H →L[ℂ] H)}
+    (hs : ∀ A ∈ s, IsSelfAdjoint A) (hc : ∀ A ∈ s, ∀ B ∈ s, A*B=B*A) :
+    ∀ A ∈ strongGenerated s, ∀ B ∈ strongGenerated s, A*B=B*A := by
+  have hle : strongGenerated s ≤ StarSubalgebra.centralizer ℂ s := by
+    apply strongGenerated_le (strong_centralizer_closed s)
+    intro B hB
+    apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+    intro A hA
+    exact ⟨hc A hA B hB, by rw [(hs A hA).star_eq]; exact hc A hA B hB⟩
+  have hle' : strongGenerated s ≤ StarSubalgebra.centralizer ℂ (strongGenerated s : Set _) := by
+    apply strongGenerated_le (strong_centralizer_closed _)
+    intro B hB
+    apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+    intro A hA
+    refine ⟨((StarSubalgebra.mem_centralizer_iff ℂ).mp (hle hA) B hB).1.symm, ?_⟩
+    exact ((StarSubalgebra.mem_centralizer_iff ℂ).mp (hle ((strongGenerated s).star_mem' hA)) B hB).1.symm
+  intro A hA B hB
+  exact ((StarSubalgebra.mem_centralizer_iff ℂ).mp (hle' hB) A hA).1
+
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BackwardIntertwiners/WeightSeparation.lean

@@ -0,0 +1,296 @@
+import OAI.Analysis.BackwardIntertwiners.CoefficientSupport
+
+namespace OAI
+
+namespace BackwardIntertwiners
+open Filter
+open scoped Topology
+noncomputable section
+
+
+structure QuadraticWeights (w : ℤ → ℝ) : Prop where
+  positive : ∀ j, 0 < w j
+  decreasing : Antitone w
+  convex_negative : DiscreteConvex (fun n => Real.log (w (-(n : ℤ))))
+  concave_positive : DiscreteConvex (fun n => -Real.log (w n))
+  root_sum : Summable (fun j : ℤ => if j = 0 then 0 else w j ^ (1 / (j : ℝ)))
+  quadratic : ∃ a : ℝ, Real.log 3 < a ∧
+    Tendsto (fun n : ℕ => Real.log (w n) / (n : ℝ)^2) atTop (𝓝 (-a)) ∧
+    Tendsto (fun n : ℕ => Real.log (w (-(n : ℤ))) / (n : ℝ)^2) atTop (𝓝 a)
+
+
+def SupportSeparation (w : ℤ → ℝ) : Prop :=
+  ∀ b c : ℤ → ℂ,
+    (∃ j, b j ≠ 0) → (∃ j, c j ≠ 0) →
+    (∀ j, ‖b j‖ ≤ w j) → (∀ j, ‖c j‖ * w j ≤ 1) →
+    (∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j - r)) = 0) →
+    ∃ t h : ℤ, b t ≠ 0 ∧ c h ≠ 0 ∧
+      (∀ j, t < j → b j = 0) ∧ (∀ j, j < h → c j = 0) ∧ t ≤ h
+
+def reflectedWeight (w : ℤ → ℝ) (j : ℤ) : ℝ := (w (-j))⁻¹
+
+lemma reflectedWeight_pos {w : ℤ → ℝ} (hw : ∀ j, 0 < w j) (j : ℤ) :
+    0 < reflectedWeight w j := inv_pos.mpr (hw _)
+
+lemma reflectedWeight_antitone {w : ℤ → ℝ} (hw : ∀ j, 0 < w j) (hdec : Antitone w) :
+    Antitone (reflectedWeight w) := by
+  intro i j hij
+  exact (inv_le_inv₀ (hw _) (hw _)).mpr (hdec (neg_le_neg hij))
+
+lemma reflected_positiveLog (w : ℤ → ℝ) : positiveLog (reflectedWeight w) = negativeLog w := by
+  funext n
+  simp [positiveLog, negativeLog, reflectedWeight, Real.log_inv]
+
+lemma reflected_negativeLog (w : ℤ → ℝ) : negativeLog (reflectedWeight w) = positiveLog w := by
+  funext n
+  simp [positiveLog, negativeLog, reflectedWeight, Real.log_inv]
+
+lemma reflected_stepRatio_summable {w : ℤ → ℝ} (hs : Summable (stepRatio w)) :
+    Summable (stepRatio (reflectedWeight w)) := by
+  have hh := hs.comp_injective (i := fun j : ℤ => -j-1) (by
+    intro a b hab; dsimp only at hab; omega)
+  apply hh.congr
+  intro j
+  dsimp [stepRatio, reflectedWeight]
+  have e₁ : -j-1+1 = -j := by omega
+  have e₂ : -(j+1) = -j-1 := by omega
+  rw [e₁, e₂, inv_div_inv]
+
+lemma reflected_correlations {b c : ℤ → ℂ}
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) :
+    ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, c (-j) * b (-(j-r))) = 0 := by
+  intro r hr
+  let e : ℤ ≃ ℤ := ⟨fun j => (r:ℤ)-j, fun j => (r:ℤ)-j, by intro j; dsimp only; omega, by intro j; dsimp only; omega⟩
+  calc (∑' j : ℤ, c (-j) * b (-(j-r))) =
+      ∑' j : ℤ, b (e j) * c (e j-r) := by
+        apply tsum_congr
+        intro j
+        dsimp [e]
+        have e₁ : (r:ℤ)-j = -(j-r) := by omega
+        have e₂ : (r:ℤ)-j-r = -j := by omega
+        rw [e₁, show -(j-(r:ℤ))-(r:ℤ) = -j by omega, mul_comm]
+    _ = ∑' j : ℤ, b j * c (j-r) := e.tsum_eq (fun j : ℤ => b j * c (j-r))
+    _ = 0 := hz r hr
+
+lemma reflected_bounds {w : ℤ → ℝ} (hw : ∀ j, 0 < w j) {b c : ℤ → ℂ}
+    (hb : ∀ j, ‖b j‖ ≤ w j) (hc : ∀ j, ‖c j‖*w j ≤ 1) :
+    (∀ j, ‖c (-j)‖ ≤ reflectedWeight w j) ∧
+    (∀ j, ‖b (-j)‖*reflectedWeight w j ≤ 1) := by
+  constructor
+  · intro j
+    simpa only [reflectedWeight, one_div] using (le_div_iff₀ (hw (-j))).mpr (hc (-j))
+  · intro j
+    dsimp [reflectedWeight]
+    rw [← div_eq_mul_inv]
+    exact (div_le_one (hw _)).mpr (hb _)
+
+
+
+theorem normalized_support_separation {w : ℤ → ℝ} (hw : ∀ j, 0 < w j)
+    (hdec : Antitone w) (hw0 : w 0 = 1)
+    (hP : DiscreteConvex (negativeLog w)) (hQ : DiscreteConvex (positiveLog w))
+    {lam δ : ℝ} (hlam : Real.log 3 < lam) (hδ : lam < δ)
+    (hqp : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ negativeLog w n)
+    (hqq : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ positiveLog w n) :
+    SupportSeparation w := by
+  intro b c hbn hcn hb hc hz
+  have hδ0 : 0 < δ := lt_trans (lt_trans (Real.log_pos (by norm_num : (1:ℝ)<3)) hlam) hδ
+  have hP0 : negativeLog w 0 = 0 := by simp [negativeLog, hw0]
+  have hQ0 : positiveLog w 0 = 0 := by simp [positiveLog, hw0]
+  have hs := stepRatio_summable hw hw0 hP hQ hδ0 hqp hqq
+  have hb_bd : ∃ m : ℤ, ∀ j : ℤ, b j ≠ 0 → j ≤ m := by
+    by_cases hc_bd : ∃ m : ℤ, ∀ j : ℤ, c j ≠ 0 → m ≤ j
+    · obtain ⟨h, hch, hh⟩ := Int.exists_least_of_bdd hc_bd hcn
+      apply bounded_above_of_min hw hdec hw0 hs hQ hδ0 hqq hb hc hch ?_ hz
+      intro j hj
+      by_contra hne
+      have := hh j hne
+      omega
+    · by_contra hbu
+      have hcu : ¬∃ m : ℤ, ∀ j : ℤ, c (-j) ≠ 0 → j ≤ m := by
+        rintro ⟨m, hm⟩
+        apply hc_bd
+        refine ⟨-m, ?_⟩
+        intro j hj
+        have hh := hm (-j) (by simpa using hj)
+        omega
+      exact no_both_unbounded (bounds_of_weight hw hb hc) hP hQ hP0 hQ0 hlam hδ hqp hqq
+        (nat_support_unbounded hbu) (nat_support_unbounded hcu) hz
+  obtain ⟨t, hbt, ht⟩ := Int.exists_greatest_of_bdd hb_bd hbn
+  have hc_bd : ∃ m : ℤ, ∀ j : ℤ, c j ≠ 0 → m ≤ j := by
+    have hwr0 : reflectedWeight w 0 = 1 := by simp [reflectedWeight, hw0]
+    have hQr : DiscreteConvex (positiveLog (reflectedWeight w)) := by
+      rw [reflected_positiveLog]; exact hP
+    have hqpr : ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ positiveLog (reflectedWeight w) n := by
+      simpa only [reflected_positiveLog] using hqp
+    obtain ⟨hbr, hcr⟩ := reflected_bounds hw hb hc
+    have hzref := reflected_correlations hz
+    have hm := bounded_above_of_min (reflectedWeight_pos hw) (reflectedWeight_antitone hw hdec)
+      hwr0 (reflected_stepRatio_summable hs) hQr hδ0 hqpr hbr hcr
+      (h := -t) (by simpa using hbt) (by
+        intro j hj
+        by_contra hne
+        have hh := ht (-j) hne
+        omega) hzref
+    obtain ⟨m, hm⟩ := hm
+    refine ⟨-m, ?_⟩
+    intro j hj
+    have hh := hm (-j) (by simpa using hj)
+    omega
+  obtain ⟨h, hch, hh⟩ := Int.exists_least_of_bdd hc_bd hcn
+  have hbmax : ∀ j : ℤ, t < j → b j = 0 := by
+    intro j hj
+    by_contra hne
+    have := ht j hne
+    omega
+  have hcmin : ∀ j : ℤ, j < h → c j = 0 := by
+    intro j hj
+    by_contra hne
+    have := hh j hne
+    omega
+  refine ⟨t, h, hbt, hch, hbmax, hcmin, ?_⟩
+  by_contra! hth
+  let r := (t-h).toNat
+  have hr : 1 ≤ r := by dsimp [r]; omega
+  have hri : (r:ℤ) = t-h := by dsimp [r]; omega
+  have he : (∑' j : ℤ, b j * c (j-r)) = b t * c h := by
+    rw [tsum_eq_single t]
+    · congr 2
+      omega
+    · intro j hj
+      by_cases hbj : b j = 0
+      · simp [hbj]
+      · have htj := ht j hbj
+        rw [hcmin _ (by omega), mul_zero]
+  have hzero := hz r hr
+  rw [he] at hzero
+  exact (mul_ne_zero hbt hch) hzero
+
+lemma DiscreteConvex.add_const {G : ℕ → ℝ} (h : DiscreteConvex G) (c : ℝ) :
+    DiscreteConvex (fun n => G n+c) := by
+  intro i j hij
+  simpa only [add_sub_add_right_eq_sub] using h hij
+
+lemma eventually_quadratic_lower {G : ℕ → ℝ} {a δ : ℝ} (hδa : δ < a)
+    (ht : Tendsto (fun n => G n / (n:ℝ)^2) atTop (𝓝 a)) :
+    ∀ᶠ n : ℕ in atTop, δ*(n:ℝ)^2 ≤ G n := by
+  filter_upwards [ht (eventually_gt_nhds hδa), eventually_ge_atTop 1] with n hn hn1
+  have hnpos : 0 < (n:ℝ)^2 := sq_pos_of_pos (Nat.cast_pos.mpr (by omega))
+  exact ((lt_div_iff₀ hnpos).mp hn).le
+
+
+
+
+theorem quadratic_support_separation (w : ℤ → ℝ) (hw : QuadraticWeights w) :
+    SupportSeparation w := by
+  let W := fun j : ℤ => w j / w 0
+  have hw0 : 0 < w 0 := hw.positive 0
+  have hWpos (j : ℤ) : 0 < W j := div_pos (hw.positive j) hw0
+  have hWdec : Antitone W := by
+    intro i j hij
+    exact div_le_div_of_nonneg_right (hw.decreasing hij) hw0.le
+  have hW0 : W 0 = 1 := div_self (ne_of_gt hw0)
+  have hlog (j : ℤ) : Real.log (w j / w 0) = Real.log (w j) - Real.log (w 0) :=
+    Real.log_div (ne_of_gt (hw.positive j)) (ne_of_gt hw0)
+  have hP : DiscreteConvex (negativeLog W) := by
+    have heq : negativeLog W = fun n : ℕ => Real.log (w (-(n:ℤ))) + -Real.log (w 0) := by
+      funext n
+      simp only [negativeLog, W, hlog, sub_eq_add_neg]
+    rw [heq]
+    exact hw.convex_negative.add_const _
+  have hQ : DiscreteConvex (positiveLog W) := by
+    have heq : positiveLog W = fun n : ℕ => -Real.log (w n) + Real.log (w 0) := by
+      funext n
+      simp only [positiveLog, W, hlog]
+      ring
+    rw [heq]
+    exact hw.concave_positive.add_const _
+  obtain ⟨a, ha, hqa, hpa⟩ := hw.quadratic
+  have hnat : Tendsto (fun n : ℕ => (n:ℝ)^2) atTop atTop := by
+    exact (tendsto_pow_atTop (by norm_num : 2 ≠ 0)).comp tendsto_natCast_atTop_atTop
+  have hsmall : Tendsto (fun n : ℕ => Real.log (w 0) / (n:ℝ)^2) atTop (𝓝 0) := by
+    simpa only [div_eq_mul_inv, mul_zero, Function.comp_def] using
+      (tendsto_inv_atTop_zero.comp hnat).const_mul (Real.log (w 0))
+  have htP : Tendsto (fun n : ℕ => negativeLog W n / (n:ℝ)^2) atTop (𝓝 a) := by
+    simpa only [negativeLog, W, hlog, sub_div, sub_zero] using hpa.sub hsmall
+  have htQ : Tendsto (fun n : ℕ => positiveLog W n / (n:ℝ)^2) atTop (𝓝 a) := by
+    have heq : (fun n : ℕ => positiveLog W n / (n:ℝ)^2) =
+        (fun n : ℕ => -(Real.log (w n) / (n:ℝ)^2) + Real.log (w 0) / (n:ℝ)^2) := by
+      funext n
+      simp only [positiveLog, W, hlog]
+      ring
+    rw [heq]
+    simpa only [neg_neg, add_zero] using hqa.neg.add hsmall
+  obtain ⟨lam, hlam, hlama⟩ := exists_between ha
+  obtain ⟨δ, hδ, hδa⟩ := exists_between hlama
+  have hsep := normalized_support_separation hWpos hWdec hW0 hP hQ hlam hδ
+    (eventually_quadratic_lower hδa htP) (eventually_quadratic_lower hδa htQ)
+  intro b c hbn hcn hb hc hz
+  let C : ℂ := (w 0 : ℂ)
+  have hC : C ≠ 0 := by dsimp [C]; exact_mod_cast (ne_of_gt hw0)
+  have hCnorm : ‖C‖ = w 0 := by simpa [C] using Real.norm_of_nonneg hw0.le
+  let b' := fun j => b j / C
+  let c' := fun j => C * c j
+  have hbn' : ∃ j, b' j ≠ 0 := by
+    obtain ⟨j, hj⟩ := hbn
+    exact ⟨j, div_ne_zero hj hC⟩
+  have hcn' : ∃ j, c' j ≠ 0 := by
+    obtain ⟨j, hj⟩ := hcn
+    exact ⟨j, mul_ne_zero hC hj⟩
+  have hb' (j : ℤ) : ‖b' j‖ ≤ W j := by
+    dsimp [b', W]
+    rw [norm_div, hCnorm]
+    exact div_le_div_of_nonneg_right (hb j) hw0.le
+  have hc' (j : ℤ) : ‖c' j‖ * W j ≤ 1 := by
+    dsimp [c', W]
+    rw [norm_mul, hCnorm]
+    have he : w 0 * ‖c j‖ * (w j / w 0) = ‖c j‖ * w j := by field_simp
+    rw [he]
+    exact hc j
+  have hz' (r : ℕ) (hr : 1 ≤ r) : (∑' j : ℤ, b' j * c' (j-r)) = 0 := by
+    have he (j : ℤ) : b' j * c' (j-r) = b j * c (j-r) := by
+      dsimp [b', c']
+      field_simp
+    simp only [he]
+    exact hz r hr
+  have hh := hsep b' c' hbn' hcn' hb' hc' hz'
+  simpa [b', c', hC] using hh
+
+
+lemma SupportSeparation.of_bounded {w : ℤ → ℝ} (hsep : SupportSeparation w)
+    {b c : ℤ → ℂ} (hbn : ∃ j, b j ≠ 0) (hcn : ∃ j, c j ≠ 0)
+    {B C : ℝ} (hB : 0 < B) (hC : 0 < C)
+    (hb : ∀ j, ‖b j‖ ≤ B*w j) (hc : ∀ j, ‖c j‖*w j ≤ C)
+    (hz : ∀ r : ℕ, 1 ≤ r → (∑' j : ℤ, b j * c (j-r)) = 0) :
+    ∃ t h : ℤ, b t ≠ 0 ∧ c h ≠ 0 ∧
+      (∀ j, t < j → b j = 0) ∧ (∀ j, j < h → c j = 0) ∧ t ≤ h := by
+  have hBC : (B:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt hB)
+  have hCC : (C:ℂ) ≠ 0 := by exact_mod_cast (ne_of_gt hC)
+  let b' := fun j => b j / (B:ℂ)
+  let c' := fun j => c j / (C:ℂ)
+  have hbn' : ∃ j, b' j ≠ 0 := by
+    obtain ⟨j, hj⟩ := hbn
+    exact ⟨j, div_ne_zero hj hBC⟩
+  have hcn' : ∃ j, c' j ≠ 0 := by
+    obtain ⟨j, hj⟩ := hcn
+    exact ⟨j, div_ne_zero hj hCC⟩
+  have hb' (j : ℤ) : ‖b' j‖ ≤ w j := by
+    dsimp [b']
+    rw [norm_div, Complex.norm_real, Real.norm_of_nonneg hB.le]
+    exact (div_le_iff₀ hB).mpr (by simpa only [mul_comm] using hb j)
+  have hc' (j : ℤ) : ‖c' j‖*w j ≤ 1 := by
+    dsimp [c']
+    rw [norm_div, Complex.norm_real, Real.norm_of_nonneg hC.le, div_mul_eq_mul_div]
+    exact (div_le_one hC).mpr (hc j)
+  have hz' (r : ℕ) (hr : 1 ≤ r) : (∑' j : ℤ, b' j * c' (j-r)) = 0 := by
+    have he (j : ℤ) : b' j * c' (j-r) = (b j*c (j-r)) / ((B:ℂ)*(C:ℂ)) := by
+      dsimp [b', c']; ring
+    simp only [he, tsum_div_const, hz r hr, zero_div]
+  have hh := hsep b' c' hbn' hcn' hb' hc' hz'
+  simpa [b', c', hBC, hCC] using hh
+
+
+end
+end BackwardIntertwiners
+
+end OAI

lean/OAI/Analysis/BernoulliCone/BoundedCalibration.lean

@@ -0,0 +1,121 @@
+import OAI.Analysis.BernoulliCone.ExteriorCalibration
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+
+def upperFlux (p:Space 7×ℝ) : Space 7 :=
+  if U p.1<p.2 then
+    κ • (if Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≤1
+      then gradient smoothCap ((upperParameter p.1 p.2)⁻¹ • p.1)
+      else gradient outerSigned ((upperParameter p.1 p.2)⁻¹ • p.1))
+  else 0
+lemma upperParameter_signed_pos {p:Space 7×ℝ} (hp:U p.1<p.2) :
+    0<upperSigned ((upperParameter p.1 p.2)⁻¹ • p.1) := by
+  obtain ⟨hl,he⟩:=upperParameter_spec hp
+  have hpos:0<upperFamily (upperParameter p.1 p.2) p.1:=by
+    rw [he]; exact (U_nonneg _).trans_lt hp
+  have hh:0 < max (upperSigned ((upperParameter p.1 p.2)⁻¹ • p.1)) 0:=
+    pos_of_mul_pos_right hpos (mul_nonneg κ_pos.le hl.le)
+  simpa using hh
+lemma upperFlux_uniform_bound : ∃C:ℝ,0<C ∧ ∀p:Space 7×ℝ,‖upperFlux p‖≤C := by
+  obtain ⟨C,hC,hcap⟩:=cap_gradient_uniform_bound
+  obtain ⟨D,hD,hext⟩:=outer_gradient_uniform_bound
+  refine ⟨κ*(C+D),mul_pos κ_pos (add_pos hC hD),?_⟩
+  intro p
+  by_cases hp:U p.1<p.2
+  · have hpos:=upperParameter_signed_pos hp
+    rw [upperFlux,ite_eq_left hp,norm_smul,Real.norm_eq_abs,abs_of_pos κ_pos]
+    apply mul_le_mul_of_nonneg_left _ κ_pos.le
+    split_ifs with hq
+    · rw [upperSigned_cap hq] at hpos
+      exact (hcap _ hq hpos).trans (by linarith)
+    · have hq':1≤Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1):=
+        (lt_of_not_ge hq).le
+      rw [upperSigned_outer hq'] at hpos
+      exact (hext _ hq' hpos).trans (by linarith)
+  · simp only [upperFlux,ite_eq_right hp,norm_zero]
+    exact mul_nonneg κ_pos.le (by linarith)
+lemma upperSigned_gradient_cap {x:Space 7} (hq:Cylindrical.radiusSq axis x<1) :
+    gradient upperSigned x=gradient smoothCap x := by
+  have hc:ContinuousAt (Cylindrical.radiusSq axis) x:=
+    (Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt
+  have he:upperSigned =ᶠ[𝓝 x] smoothCap:=by
+    filter_upwards [hc.eventually (gt_mem_nhds hq)] with y hy
+    exact upperSigned_cap hy.le
+  exact congrArg ((toDual ℝ (Space 7)).symm) he.fderiv_eq
+lemma upperSigned_gradient_outer {x:Space 7} (hq:1<Cylindrical.radiusSq axis x) :
+    gradient upperSigned x=gradient outerSigned x := by
+  have hc:ContinuousAt (Cylindrical.radiusSq axis) x:=
+    (Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt
+  have he:upperSigned =ᶠ[𝓝 x] outerSigned:=by
+    filter_upwards [hc.eventually (lt_mem_nhds hq)] with y hy
+    exact upperSigned_outer hy.le
+  exact congrArg ((toDual ℝ (Space 7)).symm) he.fderiv_eq
+lemma upperFlux_eq_calibration {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≠1) :
+    upperFlux p=upperCalibration p := by
+  rw [upperCalibration_eq hp hq,upperFlux,ite_eq_left hp]
+  congr 1
+  rcases lt_or_gt_of_ne hq with h|h
+  · rw [ite_eq_left h.le,upperSigned_gradient_cap h]
+  · rw [ite_eq_right (not_le.mpr h),upperSigned_gradient_outer h]
+lemma upperFlux_eventually_eq {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≠1) :
+    upperFlux =ᶠ[𝓝 p] upperCalibration := by
+  have hn:∀ᶠ z:Space 7×ℝ in 𝓝 p,U z.1<z.2:=
+    (U_continuous.continuousAt.comp continuous_fst.continuousAt).eventually_lt
+      continuous_snd.continuousAt hp
+  have hl:upperParameter p.1 p.2≠0:=(upperParameter_spec hp).1.ne'
+  have hc:ContinuousAt (fun z:Space 7×ℝ=>
+      Cylindrical.radiusSq axis ((upperParameter z.1 z.2)⁻¹ • z.1)) p:=
+    (Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt.comp
+      (((upperParameter_contDiffAt hp hq).continuousAt.inv₀ hl).smul continuous_fst.continuousAt)
+  filter_upwards [hn,hc.eventually_ne hq] with z hz hzq
+  exact upperFlux_eq_calibration hz hzq
+lemma upperFlux_contDiffAt {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≠1) :
+    ContDiffAt ℝ ∞ upperFlux p :=
+  (upperCalibration_contDiffAt hp hq).congr_of_eventuallyEq (upperFlux_eventually_eq hp hq)
+lemma upperParameter_measurable : Measurable (fun z:Space 7×ℝ=>upperParameter z.1 z.2) := by
+  let S:Set (Space 7×ℝ):={z|U z.1<z.2}
+  have hS:IsOpen S:=isOpen_lt (U_continuous.comp continuous_fst) continuous_snd
+  have hh:Measurable (S.piecewise (fun z=>upperParameter z.1 z.2) (fun _=>0)):=
+    upperParameter_continuousOn.measurable_piecewise continuousOn_const hS.measurableSet
+  convert hh using 1
+  ext z
+  by_cases hz:U z.1<z.2
+  · simp [S,hz]
+  · simp [S,hz,upperParameter]
+lemma upperFlux_measurable : Measurable upperFlux := by
+  have hi:Measurable (fun z:Space 7×ℝ=>(upperParameter z.1 z.2)⁻¹ • z.1):=
+    upperParameter_measurable.inv.smul measurable_fst
+  have hq:Measurable (fun z:Space 7×ℝ=>Cylindrical.radiusSq axis ((upperParameter z.1 z.2)⁻¹ • z.1)):=
+    (Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.measurable.comp hi
+  have h1:MeasurableSet {z:Space 7×ℝ|U z.1<z.2}:=
+    measurableSet_lt (U_continuous.measurable.comp measurable_fst) measurable_snd
+  have h2:MeasurableSet {z:Space 7×ℝ|Cylindrical.radiusSq axis ((upperParameter z.1 z.2)⁻¹ • z.1)≤1}:=
+    measurableSet_le hq measurable_const
+  exact ((LipschitzSobolev.measurable_gradient.comp hi).ite h2
+    (LipschitzSobolev.measurable_gradient.comp hi)).const_smul κ |>.ite h1 measurable_const
+
+/-- The height primitive is integrable and has linear growth, using the actual
+field's uniform bound, independently of seam choices. -/
+lemma upperFlux_intervalIntegrable (x:Space 7) (a b:ℝ) :
+    IntervalIntegrable (fun s:ℝ=>upperFlux (x,s)) MeasureTheory.volume a b := by
+  obtain ⟨C,hC,hbound⟩:=upperFlux_uniform_bound
+  rw [intervalIntegrable_iff]
+  apply MeasureTheory.Integrable.mono' (g:=fun _:ℝ=>C)
+    (intervalIntegrable_const (a:=a) (b:=b) (c:=C)).def'
+  · exact (upperFlux_measurable.comp (measurable_const.prodMk measurable_id)).aestronglyMeasurable
+  · exact Filter.Eventually.of_forall fun s=>hbound (x,s)
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CalibrationTraces.lean

@@ -0,0 +1,89 @@
+import OAI.Analysis.BernoulliCone.OuterSlope
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.DeSilvaJerison
+lemma gradient_dilation {f:Space 7→ℝ} {x:Space 7} {l:ℝ} (hl:l≠0)
+    (hf:DifferentiableAt ℝ f (l⁻¹ • x)) :
+    gradient (fun y=>κ*l*f (l⁻¹ • y)) x=κ • gradient f (l⁻¹ • x) := by
+  have hd:HasFDerivAt (fun y:Space 7=>l⁻¹ • y)
+      (l⁻¹ • ContinuousLinearMap.id ℝ (Space 7)) x := (hasFDerivAt_id x).const_smul l⁻¹
+  have hh:HasFDerivAt (fun y:Space 7=>κ*l*f (l⁻¹ • y))
+      ((κ*l) • (fderiv ℝ f (l⁻¹ • x) ∘L (l⁻¹ • ContinuousLinearMap.id ℝ (Space 7)))) x :=
+    (hf.hasFDerivAt.comp x hd).const_mul (κ*l)
+  apply ext_inner_right ℝ
+  intro v
+  rw [inner_gradient_left,hh.fderiv,real_inner_smul_left,inner_gradient_left]
+  simp only [smul_apply,ContinuousLinearMap.comp_apply,
+    ContinuousLinearMap.id_apply,map_smul,smul_eq_mul]
+  field_simp
+
+lemma upperFamily_gradient {x:Space 7} {l:ℝ} (hl:0<l)
+    (hp:0<upperFamily l x) (hq:Cylindrical.radiusSq axis (l⁻¹ • x)≠1) :
+    gradient (upperFamily l) x=κ • gradient upperSigned (l⁻¹ • x) := by
+  have hf:ContDiffAt ℝ ∞ upperSigned (l⁻¹ • x):=upperSigned_contDiffAt hq
+  have hs:ContinuousAt (fun y:Space 7=>upperSigned (l⁻¹ • y)) x:=
+    hf.continuousAt.comp ((continuous_id.const_smul l⁻¹).continuousAt)
+  have hpos:0<upperSigned (l⁻¹ • x):=by
+    have hh:0 < max (upperSigned (l⁻¹ • x)) 0:=pos_of_mul_pos_right hp (mul_nonneg κ_pos.le hl.le)
+    simpa using hh
+  have he:upperFamily l =ᶠ[𝓝 x] (fun y=>κ*l*upperSigned (l⁻¹ • y)) := by
+    filter_upwards [hs.eventually (lt_mem_nhds hpos)] with y hy
+    exact congrArg (κ*l* ·) (max_eq_left hy.le)
+  rw [gradient,he.fderiv_eq]
+  exact gradient_dilation hl.ne' (hf.differentiableAt (by simp))
+
+lemma upperCalibration_eq {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≠1) :
+    upperCalibration p=κ • gradient upperSigned ((upperParameter p.1 p.2)⁻¹ • p.1) := by
+  obtain ⟨hl,he⟩:=upperParameter_spec hp
+  have hpos:0<upperFamily (upperParameter p.1 p.2) p.1:=by rw [he]; exact (U_nonneg _).trans_lt hp
+  rw [upperCalibration,Foliation.spatialGradient_eq
+    ((upperFamily_contDiffAt_swap hl hpos hq).differentiableAt (by simp))]
+  exact upperFamily_gradient hl hpos hq
+
+lemma capH_eq_zero_iff (s:ℝ) : capH s=0 ↔ |s|=3/4 := by
+  constructor
+  · intro hs
+    have h1:(|s|≤3/4):=(capH_nonneg_iff s).mp (le_of_eq hs.symm)
+    have h2:¬|s|<3/4:=by intro h; have hp:=(capH_pos_iff s).mpr h; rw [hs] at hp; exact lt_irrefl _ hp
+    exact le_antisymm h1 (not_lt.mp h2)
+  · intro hs
+    have h1:0≤capH s:=(capH_nonneg_iff s).mpr hs.le
+    have h2:¬0<capH s:=by intro h; have hp:=(capH_pos_iff s).mp h; rw [hs] at hp; exact lt_irrefl _ hp
+    exact le_antisymm (not_lt.mp h2) h1
+
+lemma smoothCap_zero_slope {x:Space 7} (hq:Cylindrical.radiusSq axis x≤1)
+    (hz:smoothCap x=0) : ‖gradient smoothCap x‖^2<c7 := by
+  have hq0:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv:0<CapAlgebra.V (Cylindrical.radiusSq axis x) capB:=
+    (CapAlgebra.V_bounds hq0 hq capB_bounds.1 capB_bounds.2).1
+  have hY:0<CapAlgebra.Y (Cylindrical.radiusSq axis x) capB capC:=
+    CapAlgebra.Y_pos hq0 hv capC_pos
+  have hh:capH (Cylindrical.axis axis x/CapAlgebra.V (Cylindrical.radiusSq axis x) capB)=0 := by
+    change CapAlgebra.Y _ _ _ * capH (_ * (CapAlgebra.V _ _)⁻¹)=0 at hz
+    simpa only [div_eq_mul_inv] using (mul_eq_zero.mp hz).resolve_left hY.ne'
+  exact smoothCap_boundary_slope_lt hq ((capH_eq_zero_iff _).mp hh)
+
+lemma normalized_slope_lt {G:Space 7} (hG:‖G‖^2<c7) : ‖κ • G‖^2<1 := by
+  rw [norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,←κ_sq]
+  exact mul_lt_mul_of_pos_left hG (sq_pos_of_pos κ_pos)
+
+theorem upper_free_boundary_slopes {x:Space 7} (hz:upperSigned x=0) :
+    (Cylindrical.radiusSq axis x≤1 → ‖κ • gradient smoothCap x‖^2<1) ∧
+    (1≤Cylindrical.radiusSq axis x → ‖κ • gradient outerSigned x‖^2<1) := by
+  constructor
+  · intro hq
+    exact normalized_slope_lt (smoothCap_zero_slope hq (by rwa [upperSigned_cap hq] at hz))
+  · intro hq
+    exact normalized_slope_lt (outer_zero_slope_lt hq (by rwa [upperSigned_outer hq] at hz))
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CapCalculus.lean

@@ -0,0 +1,263 @@
+import OAI.Analysis.BernoulliCone.UpperSupport
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.DeSilvaJerison
+namespace CapAlgebra
+lemma V_bounds {q b:ℝ} (hq:0≤q) (hq1:q≤1) (hb:2242/10000≤b) (hb1:b≤2243/10000) :
+    0<V q b ∧ V q b≤1 := by
+  have hqq : q^2≤q := by nlinarith
+  have he : V q b=1-(1-q)*(b-3/200*(q+1)) := by unfold V; ring
+  have hl : 0≤b*q := mul_nonneg (by linarith) hq
+  constructor
+  · unfold V
+    nlinarith
+  · rw [he]
+    have hh : 0≤(1-q)*(b-3/200*(q+1)) := mul_nonneg (by linarith) (by linarith)
+    linarith
+lemma hasDerivAt_V (q b:ℝ) : HasDerivAt (fun q=>V q b) (D q b/2) q := by
+  convert! (((hasDerivAt_const q (203/200-b)).add ((hasDerivAt_id q).const_mul b)).sub
+    (((hasDerivAt_id q).pow 2).const_mul (3/200))) using 1
+  dsimp [V,D]
+  ring
+lemma hasDerivAt_D (q b:ℝ) : HasDerivAt (fun q=>D q b) (-3/50) q := by
+  convert! (hasDerivAt_const q (2*b)).sub ((hasDerivAt_id q).const_mul (3/50)) using 1
+  ring
+lemma hasDerivAt_E (q b:ℝ) : HasDerivAt (fun q=>E q b) (-9/50) q := by
+  convert! (hasDerivAt_const q (2*b)).sub ((hasDerivAt_id q).const_mul (9/50)) using 1
+  ring
+lemma hasDerivAt_H (q b:ℝ) : HasDerivAt (fun q=>H q b) (9/16*D q b*E q b) q := by
+  convert! (hasDerivAt_const q (1:ℝ)).add
+    ((((hasDerivAt_id q).const_mul (9/16)).mul ((hasDerivAt_D q b).pow 2))) using 1
+  dsimp [D,E]
+  ring
+lemma V_contDiff (b:ℝ) {n:WithTop ℕ∞} : ContDiff ℝ n (fun q=>V q b) := by
+  exact (contDiff_const.add (contDiff_const.mul contDiff_id)).sub (contDiff_const.mul (contDiff_id.pow 2))
+lemma H_contDiff (b:ℝ) {n:WithTop ℕ∞} : ContDiff ℝ n (fun q=>H q b) := by
+  exact contDiff_const.add ((contDiff_const.mul contDiff_id).mul
+    ((contDiff_const.sub (contDiff_const.mul contDiff_id)).pow 2))
+/-- The cap prefactor in squared transverse coordinates. -/
+def Y (q b C:ℝ) :ℝ := C*V q b/Real.sqrt (H q b)
+def Y1 (q b C:ℝ) :ℝ :=
+  C*(D q b/2/Real.sqrt (H q b)-V q b*(9/16*D q b*E q b)/(2*(Real.sqrt (H q b))^3))
+def Y2 (q b C:ℝ) :ℝ :=
+  C*((-3/100)/Real.sqrt (H q b)-D q b/2*(9/16*D q b*E q b)/(Real.sqrt (H q b))^3-
+    V q b*(9/16*((-3/50)*E q b+D q b*(-9/50)))/(2*(Real.sqrt (H q b))^3)+
+    3*V q b*(9/16*D q b*E q b)^2/(4*(Real.sqrt (H q b))^5))
+lemma Y_contDiffAt {q b C:ℝ} (hH:0<H q b) {n:WithTop ℕ∞} : ContDiffAt ℝ n (fun q=>Y q b C) q :=
+  (contDiffAt_const.mul (V_contDiff b (n:=n)).contDiffAt).div ((H_contDiff b (n:=n)).contDiffAt.sqrt hH.ne')
+    (Real.sqrt_pos.mpr hH).ne'
+lemma hasDerivAt_Y {q b C:ℝ} (hH:0<H q b) : HasDerivAt (fun q=>Y q b C) (Y1 q b C) q := by
+  have hS:=Real.sqrt_pos.mpr hH
+  have hSsq:=Real.sq_sqrt hH.le
+  convert! ((hasDerivAt_V q b).const_mul C).div ((hasDerivAt_H q b).sqrt hH.ne') hS.ne' using 1
+  simp only [Y1]
+  field_simp
+lemma hasDerivAt_Y1 {q b C:ℝ} (hH:0<H q b) : HasDerivAt (fun q=>Y1 q b C) (Y2 q b C) q := by
+  have hS:=Real.sqrt_pos.mpr hH
+  have hs := (hasDerivAt_H q b).sqrt hH.ne'
+  have hd := hasDerivAt_D q b
+  have he := hasDerivAt_E q b
+  have hv := hasDerivAt_V q b
+  convert! (((hd.div_const 2).div hs hS.ne').sub
+    ((hv.mul ((hd.const_mul (9/16)).mul he)).div ((hs.pow 3).const_mul 2) (mul_ne_zero (by norm_num) (pow_ne_zero _ hS.ne')))).const_mul C using 1
+  dsimp [Y1,Y2]
+  field_simp
+  ring
+lemma deriv_Y {q b C:ℝ} (hH:0<H q b) : deriv (fun q=>Y q b C) q=Y1 q b C := (hasDerivAt_Y hH).deriv
+lemma deriv2_Y {q b C:ℝ} (hH:0<H q b) : deriv (deriv (fun q=>Y q b C)) q=Y2 q b C := by
+  have hh : deriv (fun q=>Y q b C)=ᶠ[𝓝 q] fun q=>Y1 q b C := by
+    filter_upwards [(H_contDiff b (n:=∞)).continuous.continuousAt.eventually (Ioi_mem_nhds hH)] with t ht
+    exact deriv_Y ht
+  rw [hh.deriv_eq]
+  exact (hasDerivAt_Y1 hH).deriv
+lemma hasDerivAt_invV {q b:ℝ} (hv:V q b≠0) :
+    HasDerivAt (fun q=>(V q b)⁻¹) (-D q b/(2*(V q b)^2)) q := by
+  convert! (hasDerivAt_V q b).inv hv using 1
+  ring
+lemma deriv2_invV {q b:ℝ} (hv:V q b≠0) :
+    deriv (deriv (fun q=>(V q b)⁻¹)) q= (D q b)^2/(2*(V q b)^3)+3/(100*(V q b)^2) := by
+  have hh : deriv (fun q=>(V q b)⁻¹)=ᶠ[𝓝 q] fun q=>-D q b/(2*(V q b)^2) := by
+    filter_upwards [((V_contDiff b (n:=∞)).continuous.continuousAt.eventually_ne hv)] with t ht
+    exact (hasDerivAt_invV ht).deriv
+  rw [hh.deriv_eq]
+  have hd := ((hasDerivAt_D q b).neg.div (((hasDerivAt_V q b).pow 2).const_mul 2) (by positivity : 2*(V q b)^2≠0)).deriv
+  change deriv (fun q=>-D q b/(2*(V q b)^2)) q = _ at hd
+  rw [hd]
+  simp only [Pi.pow_apply,Pi.neg_apply]
+  field_simp
+  ring
+lemma lap_Y {q b C:ℝ} (hV:V q b≠0) (hH:0<H q b) :
+    4*q*Y2 q b C+12*Y1 q b C = Y q b C/V q b*(NN q b/(H q b)^2) := by
+  have hS := (Real.sqrt_pos.mpr hH).ne'
+  have hSq := Real.sq_sqrt hH.le
+  have hE : E q b=D q b-3/25*q := by unfold E D; ring
+  unfold Y Y1 Y2 NN MN
+  generalize hvv : V q b=v at *
+  generalize hdd : D q b=z at *
+  generalize hee : E q b=e at *
+  generalize hhh : H q b=h at *
+  have hdef : h=1+9/16*q*z^2 := by rw [←hhh, H, hdd]
+  field_simp [hS,hV,hH.ne']
+  ring_nf
+  simp only [show Real.sqrt h^4=h^2 by calc
+    _ = (Real.sqrt h^2)^2 := by ring
+    _ = _ := by rw [hSq], hSq]
+  rw [hE,hdef]
+  ring
+
+lemma invV_mixed {q b C:ℝ} (hV:V q b≠0) (hH:0<H q b) :
+    Y q b C*(4*q*((D q b)^2/(2*(V q b)^3)+3/(100*(V q b)^2))+
+      12*(-D q b/(2*(V q b)^2)))+8*q*Y1 q b C*(-D q b/(2*(V q b)^2)) =
+      -Y q b C/(V q b)^2*(MN q b/H q b) := by
+  have hS := (Real.sqrt_pos.mpr hH).ne'
+  have hSq := Real.sq_sqrt hH.le
+  have hE : E q b=D q b-3/25*q := by unfold E D; ring
+  unfold Y Y1 MN
+  generalize hvv : V q b=v at *
+  generalize hdd : D q b=z at *
+  generalize hee : E q b=e at *
+  generalize hhh : H q b=h at *
+  have hdef : h=1+9/16*q*z^2 := by rw [←hhh, H, hdd]
+  field_simp [hS,hV,hH.ne']
+  ring_nf
+  rw [hSq,hE,hdef]
+  ring
+
+end CapAlgebra
+
+lemma capH_contDiff : ContDiff ℝ ∞ capH := by
+  have hr : ContDiff ℝ ∞ capRadius := by
+    apply ContDiff.sqrt
+    · exact contDiff_const.add (contDiff_id.pow 2)
+    · intro x; positivity
+  have ht : ContDiff ℝ ∞ capAngle := contDiff_id.div hr (fun x=>(capRadius_pos x).ne')
+  have hf : ContDiff ℝ ∞ (fun s=>f (capAngle s)) := by
+    apply contDiff_iff_contDiffAt.mpr
+    intro s
+    exact (contDiffAt_f (capAngle_mem s)).comp s ht.contDiffAt
+  exact (hr.mul hf).add (contDiff_const.mul (contDiff_const.add (contDiff_const.mul (contDiff_id.pow 2))))
+
+lemma deriv2_capH (s:ℝ) : deriv (deriv capH) s=-5*(capRadius s)^3+4*capAmplitude := by
+  have hh : deriv capH=capHP := funext fun t=>(hasDerivAt_capH t).deriv
+  rw [hh]
+  exact (hasDerivAt_capHP s).deriv
+
+def capC :ℝ := Real.sqrt (1+9/16*capP^2)
+def smoothCap (x:Space 7) :ℝ := Cylindrical.lift axis (fun q=>CapAlgebra.Y q capB capC)
+  (fun q=>(CapAlgebra.V q capB)⁻¹) capH x
+
+lemma smoothCap_contDiffAt {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1) :
+    ContDiffAt ℝ ∞ smoothCap x := by
+  have hq:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv := (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  exact Cylindrical.contDiffAt_lift (CapAlgebra.Y_contDiffAt (CapAlgebra.H_pos hq))
+    ((CapAlgebra.V_contDiff capB).contDiffAt.inv hv.ne') capH_contDiff.contDiffAt
+
+lemma laplacian_smoothCap {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1) :
+    let q := Cylindrical.radiusSq axis x
+    let V := CapAlgebra.V q capB
+    let ξ := Cylindrical.axis axis x/V
+    Δ smoothCap x = CapAlgebra.Y q capB capC/V^2 *
+      ((-5*(capRadius ξ)^3+4*capAmplitude)*(1+q*ξ^2*(CapAlgebra.D q capB)^2)-
+        ξ*capHP ξ*V*(CapAlgebra.MN q capB/CapAlgebra.H q capB)+
+        capH ξ*V*(CapAlgebra.NN q capB/(CapAlgebra.H q capB)^2)) := by
+  dsimp only
+  let q := Cylindrical.radiusSq axis x
+  let a := Cylindrical.axis axis x
+  have hq : 0≤q := Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv := (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  have hh := CapAlgebra.H_pos (b:=capB) hq
+  have hc := Cylindrical.laplacian_lift axis_norm
+    (CapAlgebra.Y_contDiffAt (C:=capC) (n:=2) hh)
+    ((CapAlgebra.V_contDiff capB (n:=2)).contDiffAt.inv hv.ne')
+    (capH_contDiff.of_le (by norm_cast : (2:WithTop ℕ∞)≤∞)).contDiffAt
+  change Δ smoothCap x=_ at hc
+  simp only [Space,finrank_euclideanSpace_fin,Nat.cast_ofNat] at hc
+  norm_num only at hc
+  change Δ smoothCap x =
+    CapAlgebra.Y q capB capC * deriv (deriv capH) (a*(CapAlgebra.V q capB)⁻¹) *
+      (((CapAlgebra.V q capB)⁻¹)^2+4*q*a^2*deriv (fun q=>(CapAlgebra.V q capB)⁻¹) q^2)+
+    deriv capH (a*(CapAlgebra.V q capB)⁻¹)*
+      (a*CapAlgebra.Y q capB capC*(4*q*deriv (deriv (fun q=>(CapAlgebra.V q capB)⁻¹)) q+
+        12*deriv (fun q=>(CapAlgebra.V q capB)⁻¹) q)+
+        8*q*a*deriv (fun q=>CapAlgebra.Y q capB capC) q*deriv (fun q=>(CapAlgebra.V q capB)⁻¹) q)+
+    capH (a*(CapAlgebra.V q capB)⁻¹)*(4*q*deriv (deriv (fun q=>CapAlgebra.Y q capB capC)) q+
+      12*deriv (fun q=>CapAlgebra.Y q capB capC) q) at hc
+  rw [hc]
+  simp only [CapAlgebra.deriv_Y hh, CapAlgebra.deriv2_Y hh,
+    (CapAlgebra.hasDerivAt_invV hv.ne').deriv, CapAlgebra.deriv2_invV hv.ne',
+    deriv2_capH,(hasDerivAt_capH _).deriv]
+  change _ = CapAlgebra.Y q capB capC/(CapAlgebra.V q capB)^2 * _
+  have hm:=CapAlgebra.invV_mixed (C:=capC) hv.ne' hh
+  have hn:=CapAlgebra.lap_Y (C:=capC) hv.ne' hh
+  have h1 : ((CapAlgebra.V q capB)⁻¹)^2+4*q*a^2*(-CapAlgebra.D q capB/(2*(CapAlgebra.V q capB)^2))^2 =
+      (1+q*(a/CapAlgebra.V q capB)^2*(CapAlgebra.D q capB)^2)/(CapAlgebra.V q capB)^2 := by
+    field_simp
+    ring
+  have h2 : a*CapAlgebra.Y q capB capC*
+      (4*q*((CapAlgebra.D q capB)^2/(2*(CapAlgebra.V q capB)^3)+3/(100*(CapAlgebra.V q capB)^2))+
+        12*(-CapAlgebra.D q capB/(2*(CapAlgebra.V q capB)^2)))+
+      8*q*a*CapAlgebra.Y1 q capB capC*(-CapAlgebra.D q capB/(2*(CapAlgebra.V q capB)^2)) =
+      -a*CapAlgebra.Y q capB capC/(CapAlgebra.V q capB)^2*(CapAlgebra.MN q capB/CapAlgebra.H q capB) := by
+    calc
+      _ = a*(CapAlgebra.Y q capB capC*
+          (4*q*((CapAlgebra.D q capB)^2/(2*(CapAlgebra.V q capB)^3)+3/(100*(CapAlgebra.V q capB)^2))+
+            12*(-CapAlgebra.D q capB/(2*(CapAlgebra.V q capB)^2)))+
+          8*q*CapAlgebra.Y1 q capB capC*(-CapAlgebra.D q capB/(2*(CapAlgebra.V q capB)^2))) := by ring
+      _ = _ := by rw [hm]; ring
+  rw [h1,h2,hn]
+  change _=CapAlgebra.Y q capB capC/(CapAlgebra.V q capB)^2 *
+    ((-5*(capRadius (a/CapAlgebra.V q capB))^3+4*capAmplitude)*(1+q*(a/CapAlgebra.V q capB)^2*(CapAlgebra.D q capB)^2)-
+      (a/CapAlgebra.V q capB)*capHP (a/CapAlgebra.V q capB)*CapAlgebra.V q capB*(CapAlgebra.MN q capB/CapAlgebra.H q capB)+
+      capH (a/CapAlgebra.V q capB)*CapAlgebra.V q capB*(CapAlgebra.NN q capB/(CapAlgebra.H q capB)^2))
+  simp only [← div_eq_mul_inv]
+  field_simp
+  ring
+lemma cap_sHP_nonpos (s:ℝ) : s*capHP s≤0 := by
+  rcases le_total 0 s with h|h
+  · exact mul_nonpos_of_nonneg_of_nonpos h (capHP_nonpos h)
+  · have hh:=mul_nonpos_of_nonneg_of_nonpos (neg_nonneg.mpr h) (capHP_nonpos (neg_nonneg.mpr h))
+    simpa only [capHP_odd,neg_mul_neg] using hh
+
+/-- The actual smooth cylindrical cap is superharmonic on its positive strip. -/
+theorem smoothCap_laplacian_nonpos {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1)
+    (hs:|Cylindrical.axis axis x/CapAlgebra.V (Cylindrical.radiusSq axis x) capB|≤3/4) :
+    Δ smoothCap x≤0 := by
+  let q:=Cylindrical.radiusSq axis x
+  let V:=CapAlgebra.V q capB
+  let s:=Cylindrical.axis axis x/V
+  have hq:0≤q:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  obtain ⟨hv,hv1⟩:=CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2
+  obtain ⟨hM,hM1,hN,hN1⟩:=CapAlgebra.coeff_bounds hq hx capB_bounds.1 capB_bounds.2
+  have hh:=capH_nonneg hs
+  have hph:=capHPP_nonpos s
+  have hsp:=cap_sHP_nonpos s
+  have hK:=cap_K_nonpos hs
+  change -5*capRadius s^3+4*capAmplitude-(673/250)*s*capHP s+(431/200)*capH s≤0 at hK
+  have hvm : V*(CapAlgebra.MN q capB/CapAlgebra.H q capB)≤673/250 :=
+    (mul_le_mul_of_nonneg_right hv1 hM).trans (by simpa using hM1)
+  have hvn : V*(CapAlgebra.NN q capB/(CapAlgebra.H q capB)^2)≤431/200 :=
+    (mul_le_mul_of_nonneg_right hv1 hN).trans (by simpa using hN1)
+  have h0:=mul_nonpos_of_nonpos_of_nonneg hph
+    (show 0≤q*s^2*(CapAlgebra.D q capB)^2 by positivity)
+  have h1:=mul_le_mul_of_nonneg_left hvm (neg_nonneg.mpr hsp)
+  have h2:=mul_le_mul_of_nonneg_left hvn hh
+  have hbr : (-5*capRadius s^3+4*capAmplitude)*(1+q*s^2*(CapAlgebra.D q capB)^2)-
+      s*capHP s*V*(CapAlgebra.MN q capB/CapAlgebra.H q capB)+
+      capH s*V*(CapAlgebra.NN q capB/(CapAlgebra.H q capB)^2)≤0 := by
+    nlinarith only [h0,h1,h2,hK]
+  rw [laplacian_smoothCap hx]
+  have hY:0≤CapAlgebra.Y q capB capC := by unfold CapAlgebra.Y capC; positivity
+  exact mul_nonpos_of_nonneg_of_nonpos (div_nonneg hY (sq_nonneg V)) hbr
+
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CapExtension.lean

@@ -0,0 +1,90 @@
+import OAI.Analysis.BernoulliCone.BoundedCalibration
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+
+lemma upperFamily_eq_cap {x:Space 7} {l:ℝ} (hl:0<l)
+    (hp:0<upperFamily l x) (hq:Cylindrical.radiusSq axis (l⁻¹ • x)≤1) :
+    upperFamily l x=κ*l*smoothCap (l⁻¹ • x) := by
+  have hh:0 < max (upperSigned (l⁻¹ • x)) 0:=
+    pos_of_mul_pos_right hp (mul_nonneg κ_pos.le hl.le)
+  have hs:0<upperSigned (l⁻¹ • x):=by simpa using hh
+  rw [upperFamily,max_eq_left hs.le,upperSigned_cap hq]
+
+/-- Smooth signed extensions of the inverse cap parameter through the actual
+cap/exterior interface, obtained by IFT with local uniqueness. -/
+lemma capParameter_local_extension {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≤1) :
+    ∃ψ:Space 7×ℝ→ℝ,ContDiffAt ℝ ∞ ψ p ∧ ψ p=upperParameter p.1 p.2 ∧
+      ∀ᶠ z in 𝓝 p, U z.1<z.2 →
+        Cylindrical.radiusSq axis ((upperParameter z.1 z.2)⁻¹ • z.1)≤1 →
+        ψ z=upperParameter z.1 z.2 := by
+  let l:=upperParameter p.1 p.2
+  have hl:0<l:=(upperParameter_spec hp).1
+  have he:upperFamily l p.1=p.2:=(upperParameter_spec hp).2
+  have hpos:0<upperFamily l p.1:=he.symm ▸ (U_nonneg p.1).trans_lt hp
+  have hc:ContDiffAt ℝ ∞ smoothCap (l⁻¹ • p.1):=smoothCap_contDiffAt hq
+  have hpc:0<smoothCap (l⁻¹ • p.1):=by
+    rw [←upperSigned_cap hq]
+    exact upperParameter_signed_pos hp
+  let F:(Space 7×ℝ)×ℝ→ℝ:=fun z=>κ*z.2*smoothCap (z.2⁻¹ • z.1.1)-z.1.2
+  have hi:ContDiffAt ℝ ∞ (fun z:(Space 7×ℝ)×ℝ=>z.2⁻¹ • z.1.1) (p,l):=
+    (contDiffAt_snd.inv hl.ne').smul (contDiffAt_fst.fst)
+  have hF:ContDiffAt ℝ ∞ F (p,l):=
+    ((contDiffAt_const.mul contDiffAt_snd).mul (hc.comp (p,l) hi)).sub contDiffAt_fst.snd
+  let ρ:=κ*(smoothCap (l⁻¹ • p.1)-inner ℝ (l⁻¹ • p.1) (gradient smoothCap (l⁻¹ • p.1)))
+  have hρ:0<ρ:=mul_pos κ_pos (smoothCap_radial_defect_pos hq hpc)
+  have hd:HasDerivAt (fun s:ℝ=>F (p,s)) ρ l := by
+    have hh:=((Foliation.hasDerivAt_dilate p.1 hl.ne'
+      (hc.differentiableAt (by simp))).const_mul κ).sub_const p.2
+    simpa only [F,mul_assoc] using hh
+  obtain ⟨ψ,hψ,hψ0,hψeq,huniq⟩:=Foliation.scalar_implicit_unique hF hd hρ.ne'
+  refine ⟨ψ,hψ,hψ0,?_⟩
+  have hF0:F (p,l)=0:=by
+    dsimp [F]
+    rw [←upperFamily_eq_cap hl hpos hq,he,sub_self]
+  have ht:Tendsto (fun z:Space 7×ℝ=>(z,upperParameter z.1 z.2)) (𝓝 p) (𝓝 (p,l)):=
+    tendsto_id.prodMk_nhds (upperParameter_continuousAt hp)
+  filter_upwards [ht.eventually huniq] with z hz hzp hzq
+  apply hz.mp
+  rw [hF0]
+  dsimp [F]
+  have hzpos:0<upperFamily (upperParameter z.1 z.2) z.1:=
+    (upperParameter_spec hzp).2.symm ▸ (U_nonneg z.1).trans_lt hzp
+  rw [←upperFamily_eq_cap (upperParameter_spec hzp).1 hzpos hzq,
+    (upperParameter_spec hzp).2,sub_self]
+
+lemma gradient_smoothCap_contDiffAt {x:Space 7} (hq:Cylindrical.radiusSq axis x≤1) :
+    ContDiffAt ℝ ∞ (gradient smoothCap) x := by
+  exact (toDual ℝ (Space 7)).symm.contDiff.contDiffAt.comp x
+    ((smoothCap_contDiffAt hq).fderiv_right (by simp))
+
+/-- The actual one-sided cap flux admits a smooth germ even at the seam.
+No regularity of the discontinuous full flux is asserted. -/
+theorem upperFlux_cap_local_extension {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≤1) :
+    ∃B:Space 7×ℝ→Space 7,ContDiffAt ℝ ∞ B p ∧ B p=upperFlux p ∧
+      ∀ᶠ z in 𝓝 p,U z.1<z.2 →
+        Cylindrical.radiusSq axis ((upperParameter z.1 z.2)⁻¹ • z.1)≤1 → B z=upperFlux z := by
+  obtain ⟨ψ,hψ,hψ0,he⟩:=capParameter_local_extension hp hq
+  let B:Space 7×ℝ→Space 7:=fun z=>κ • gradient smoothCap ((ψ z)⁻¹ • z.1)
+  have hψp:ψ p≠0:=by rw [hψ0]; exact (upperParameter_spec hp).1.ne'
+  have hn:ContDiffAt ℝ ∞ (fun z:Space 7×ℝ=>(ψ z)⁻¹ • z.1) p:=
+    (hψ.inv hψp).smul contDiffAt_fst
+  have hg:ContDiffAt ℝ ∞ (gradient smoothCap) ((ψ p)⁻¹ • p.1):=by
+    rw [hψ0]; exact gradient_smoothCap_contDiffAt hq
+  refine ⟨B,(hg.comp p hn).const_smul κ,?_,?_⟩
+  · simp only [B,hψ0,upperFlux,ite_eq_left hp,ite_eq_left hq]
+  · filter_upwards [he] with z hz hzp hzq
+    simp only [B,hz hzp hzq,upperFlux,ite_eq_left hzp,ite_eq_left hzq]
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CapFoliation.lean

@@ -0,0 +1,139 @@
+import OAI.Analysis.BernoulliCone.CapGeometry
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.DeSilvaJerison
+
+lemma capHP_mul_nonpos (s:ℝ) : s*capHP s≤0 := by
+  rcases le_total 0 s with h|h
+  · exact mul_nonpos_of_nonneg_of_nonpos h (capHP_nonpos h)
+  · have hh:=capHP_nonpos (s:= -s) (by linarith)
+    rw [capHP_odd] at hh
+    exact mul_nonpos_of_nonpos_of_nonneg h (by linarith)
+
+lemma capHP_neg {s:ℝ} (hs:0<s) : capHP s<0 := by
+  have hh:=capHP_le_linear hs.le
+  have hn: -5+4*capAmplitude<0 := by linarith [capAmplitude_le]
+  exact hh.trans_lt (mul_neg_of_neg_of_pos hn hs)
+
+lemma capH_strictAnti : StrictAntiOn capH (Ici 0) := by
+  apply strictAntiOn_of_deriv_neg (convex_Ici _)
+  · intro x hx
+    exact (hasDerivAt_capH x).continuousAt.continuousWithinAt
+  · intro x hx
+    rw [interior_Ici] at hx
+    rw [(hasDerivAt_capH x).deriv]
+    exact capHP_neg hx
+
+lemma capH_pos_iff (s:ℝ) : 0<capH s ↔ |s|<3/4 := by
+  rw [←capH_abs]
+  constructor
+  · intro hh
+    by_contra hn
+    have hh1:=capH_antitone (show (3/4:ℝ)∈Ici 0 by norm_num)
+      (abs_nonneg s) (le_of_not_gt hn)
+    rw [capH_end] at hh1
+    linarith
+  · intro hs
+    have hh:=capH_strictAnti (abs_nonneg s) (show (3/4:ℝ)∈Ici 0 by norm_num) hs
+    rwa [capH_end] at hh
+
+namespace CapAlgebra
+lemma V_radial_pos {q b:ℝ} (_hq:0≤q) (hq1:q≤1) (hb:2242/10000≤b) (hb1:b≤2243/10000) :
+    0<V q b-q*D q b := by
+  have hmul:q*b≤b:=mul_le_of_le_one_left (by linarith) hq1
+  unfold V D
+  nlinarith [sq_nonneg q]
+lemma D_pos {q b:ℝ} (hq1:q≤1) (hb:2242/10000≤b) :0<D q b := by
+  unfold D; linarith
+lemma E_pos {q b:ℝ} (hq1:q≤1) (hb:2242/10000≤b) :0<E q b := by
+  unfold E; linarith
+lemma Y_pos {q b C:ℝ} (hq:0≤q) (hv:0<V q b) (hc:0<C) :0<Y q b C := by
+  unfold Y; exact div_pos (mul_pos hc hv) (Real.sqrt_pos.mpr (H_pos hq))
+lemma Y1_eq {q b C:ℝ} (hh:0<H q b) (hv:V q b≠0) :
+    2*Y1 q b C=Y q b C*(D q b/V q b-9/16*D q b*E q b/H q b) := by
+  have hs:Real.sqrt (H q b)≠0:=(Real.sqrt_pos.mpr hh).ne'
+  have hs2:=Real.sq_sqrt hh.le
+  unfold Y1 Y
+  generalize V q b=v at *
+  generalize D q b=d at *
+  generalize E q b=e at *
+  generalize H q b=h at *
+  field_simp
+  rw [hs2]
+  ring
+end CapAlgebra
+
+lemma smoothCap_radial_defect {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1) :
+    let q:=Cylindrical.radiusSq axis x
+    let V:=CapAlgebra.V q capB
+    let H:=CapAlgebra.H q capB
+    let D:=CapAlgebra.D q capB
+    let E:=CapAlgebra.E q capB
+    let s:=Cylindrical.axis axis x/V
+    smoothCap x-inner ℝ x (gradient smoothCap x)=
+      CapAlgebra.Y q capB capC*((1-q*D/V+q*9/16*D*E/H)*capH s-
+        s*capHP s*(1-q*D/V)) := by
+  dsimp only
+  let q:=Cylindrical.radiusSq axis x
+  let a:=Cylindrical.axis axis x
+  have hq:0≤q:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv:0<CapAlgebra.V q capB:= (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  have hh:0<CapAlgebra.H q capB:=CapAlgebra.H_pos hq
+  have ht:inner ℝ x (Cylindrical.transverse axis x)=q := by
+    simp only [Cylindrical.transverse,inner_sub_right,real_inner_smul_right,
+      real_inner_self_eq_norm_sq]
+    change ‖x‖^2-a*a=‖x‖^2-a^2
+    ring
+  rw [gradient_smoothCap hx]
+  simp only [inner_add_right,real_inner_smul_right,ht]
+  change smoothCap x-(2*CapAlgebra.Y1 q capB capC*capH (a/CapAlgebra.V q capB)*q+
+    CapAlgebra.Y q capB capC*capHP (a/CapAlgebra.V q capB)*
+      ((CapAlgebra.V q capB)⁻¹*a+(-a*CapAlgebra.D q capB/(CapAlgebra.V q capB)^2)*q))=_
+  rw [CapAlgebra.Y1_eq hh hv.ne']
+  change CapAlgebra.Y q capB capC*capH (a*(CapAlgebra.V q capB)⁻¹)-_=_
+  dsimp only [q,a] at *
+  simp only [div_eq_mul_inv]
+  field_simp
+  ring
+
+lemma smoothCap_radial_defect_pos {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1)
+    (hp:0<smoothCap x) : 0<smoothCap x-inner ℝ x (gradient smoothCap x) := by
+  let q:=Cylindrical.radiusSq axis x
+  let V:=CapAlgebra.V q capB
+  let H:=CapAlgebra.H q capB
+  let D:=CapAlgebra.D q capB
+  let E:=CapAlgebra.E q capB
+  let s:=Cylindrical.axis axis x/V
+  have hq:0≤q:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv:0<V:= (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  have hh:0<H:=CapAlgebra.H_pos hq
+  have hd:0<D:=CapAlgebra.D_pos hx capB_bounds.1
+  have he:0<E:=CapAlgebra.E_pos hx capB_bounds.1
+  have hy:0<CapAlgebra.Y q capB capC:=CapAlgebra.Y_pos hq hv capC_pos
+  have hhpos:0<capH s := by
+    change 0<CapAlgebra.Y q capB capC*capH (Cylindrical.axis axis x*V⁻¹) at hp
+    rw [←div_eq_mul_inv] at hp
+    exact pos_of_mul_pos_right hp hy.le
+  have hk:0<1-q*D/V := by
+    have hl:=CapAlgebra.V_radial_pos hq hx capB_bounds.1 capB_bounds.2
+    apply sub_pos.mpr
+    apply (div_lt_iff₀ hv).mpr
+    simpa only [one_mul] using (show q*D<V by linarith)
+  have hk1:0≤q*9/16*D*E/H:=by positivity
+  have hsprod:=capHP_mul_nonpos s
+  rw [smoothCap_radial_defect hx]
+  change 0<CapAlgebra.Y q capB capC*((1-q*D/V+q*9/16*D*E/H)*capH s-s*capHP s*(1-q*D/V))
+  have ht:=mul_pos (show 0<1-q*D/V+q*9/16*D*E/H by linarith) hhpos
+  have ht1:=mul_nonpos_of_nonpos_of_nonneg hsprod hk.le
+  exact mul_pos hy (by linarith)
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CapGeometry.lean

@@ -0,0 +1,122 @@
+import OAI.Analysis.BernoulliCone.CapCalculus
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.DeSilvaJerison
+
+lemma capH_abs (s:ℝ) : capH |s|=capH s := by
+  rcases le_total 0 s with h|h
+  · rw [abs_of_nonneg h]
+  · rw [abs_of_nonpos h,capH_even]
+lemma capHP_sq_abs (s:ℝ) : (capHP |s|)^2=(capHP s)^2 := by
+  rcases le_total 0 s with h|h
+  · rw [abs_of_nonneg h]
+  · rw [abs_of_nonpos h,capHP_odd,neg_sq]
+lemma capH_boundary {s:ℝ} (hs:|s|=3/4) : capH s=0 := by
+  rw [←capH_abs,hs,capH_end]
+lemma capHP_sq_boundary {s:ℝ} (hs:|s|=3/4) : (capHP s)^2=(capHP (3/4))^2 := by
+  rw [←capHP_sq_abs,hs]
+lemma capC_pos : 0<capC := by unfold capC; positivity
+lemma capC_sq : capC^2=1+9/16*capP^2 := Real.sq_sqrt (by positivity)
+lemma cap_boundary_slope_bound : capC^2*(capHP (3/4))^2≤c7 := by
+  have hp := capP_bounds
+  have ha := capAmplitude_bounds
+  have hs : capP^2≤(3886/10000:ℝ)^2 := by nlinarith [hp.1,hp.2]
+  have hq : 0≤3125/768-capAmplitude/6 := by linarith [ha.2]
+  have hq1 : (3125/768-capAmplitude/6)^2≤(3125/768-(289237/1000000)/6:ℝ)^2 := by
+    nlinarith [ha.1]
+  rw [capC_sq,capHP_end]
+  have hprod := mul_le_mul (show 1+9/16*capP^2≤1+9/16*(3886/10000:ℝ)^2 by linarith)
+    hq1 (sq_nonneg _) (by positivity : (0:ℝ)≤1+9/16*(3886/10000:ℝ)^2)
+  nlinarith only [hprod,c7_lower]
+
+lemma gradient_smoothCap {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1) :
+    let q := Cylindrical.radiusSq axis x
+    let V := CapAlgebra.V q capB
+    let s := Cylindrical.axis axis x/V
+    gradient smoothCap x =
+      (2*CapAlgebra.Y1 q capB capC*capH s) • Cylindrical.transverse axis x +
+      (CapAlgebra.Y q capB capC*capHP s) •
+        (V⁻¹ • axis+(-Cylindrical.axis axis x*CapAlgebra.D q capB/V^2) • Cylindrical.transverse axis x) := by
+  dsimp only
+  let q:=Cylindrical.radiusSq axis x
+  let a:=Cylindrical.axis axis x
+  have hq:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hh:0<CapAlgebra.H q capB:=CapAlgebra.H_pos (b:=capB) hq
+  have hv:0<CapAlgebra.V q capB:= (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  have hg:=Cylindrical.gradient_lift (e:=axis) (x:=x)
+    (CapAlgebra.Y_contDiffAt (C:=capC) (n:=1) hh |>.differentiableAt (by norm_num))
+    (CapAlgebra.hasDerivAt_invV hv.ne').differentiableAt
+    (hasDerivAt_capH _).differentiableAt
+  change gradient smoothCap x= _ at hg
+  change gradient smoothCap x=
+    (2*deriv (fun q=>CapAlgebra.Y q capB capC) q*capH (a*(CapAlgebra.V q capB)⁻¹)) • Cylindrical.transverse axis x+
+    (CapAlgebra.Y q capB capC*deriv capH (a*(CapAlgebra.V q capB)⁻¹)) •
+      ((CapAlgebra.V q capB)⁻¹ • axis+(2*a*deriv (fun q=>(CapAlgebra.V q capB)⁻¹) q) • Cylindrical.transverse axis x) at hg
+  rw [hg]
+  simp only [CapAlgebra.deriv_Y hh,(CapAlgebra.hasDerivAt_invV hv.ne').deriv,
+    (hasDerivAt_capH _).deriv,←div_eq_mul_inv]
+  have he:2*a*(-CapAlgebra.D q capB/(2*CapAlgebra.V q capB^2)) = -a*CapAlgebra.D q capB/CapAlgebra.V q capB^2 := by ring
+  rw [he]
+
+/-- Constant free-boundary slope of the actual cylindrical cap, including the
+transverse axis. The result is for the genuine Euclidean gradient. -/
+theorem smoothCap_boundary_gradient {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1)
+    (hs:|Cylindrical.axis axis x/CapAlgebra.V (Cylindrical.radiusSq axis x) capB|=3/4) :
+    ‖gradient smoothCap x‖^2=capC^2*(capHP (3/4))^2 := by
+  let q:=Cylindrical.radiusSq axis x
+  let a:=Cylindrical.axis axis x
+  let V:=CapAlgebra.V q capB
+  let H:=CapAlgebra.H q capB
+  let s:=a/V
+  have hq:0≤q:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  have hv:0<V:= (CapAlgebra.V_bounds hq hx capB_bounds.1 capB_bounds.2).1
+  have hh:0<H:=CapAlgebra.H_pos hq
+  have hs2 : s^2=9/16 := by nlinarith only [sq_abs s,hs]
+  have hz : capH s=0 := capH_boundary hs
+  have hp : (capHP s)^2=(capHP (3/4))^2 := capHP_sq_boundary hs
+  have hg:=gradient_smoothCap hx
+  dsimp only at hg
+  change gradient smoothCap x=(2*CapAlgebra.Y1 q capB capC*capH s) • Cylindrical.transverse axis x+
+    (CapAlgebra.Y q capB capC*capHP s) •
+      (V⁻¹ • axis+(-a*CapAlgebra.D q capB/V^2) • Cylindrical.transverse axis x) at hg
+  rw [hz] at hg
+  simp only [mul_zero,zero_smul,zero_add] at hg
+  have horth:inner ℝ axis (Cylindrical.transverse axis x)=0 := by
+    rw [real_inner_comm,Cylindrical.transverse_inner axis x axis_norm]
+  rw [hg,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,norm_add_sq_real]
+  simp only [norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,axis_norm,mul_one,
+    real_inner_smul_left,real_inner_smul_right,horth,mul_zero,add_zero,
+    Cylindrical.transverse_sq axis x axis_norm]
+  change (CapAlgebra.Y q capB capC)^2*(capHP s)^2*
+    ((V⁻¹)^2+(-a*CapAlgebra.D q capB/V^2)^2*q)=_
+  have he : ((V⁻¹)^2+(-a*CapAlgebra.D q capB/V^2)^2*q)=H/V^2 := by
+    have hhdef : H=1+9/16*q*(CapAlgebra.D q capB)^2:=rfl
+    have ha2 : a^2=9/16*V^2 := by
+      dsimp only [s] at hs2
+      field_simp at hs2
+      nlinarith only [hs2]
+    field_simp
+    rw [ha2,hhdef]
+    ring
+  rw [he,hp]
+  unfold CapAlgebra.Y
+  change (capC*V/Real.sqrt H)^2*(capHP (3/4))^2*(H/V^2)=_
+  rw [div_pow,mul_pow,Real.sq_sqrt hh.le]
+  field_simp
+
+ theorem smoothCap_boundary_slope {x:Space 7} (hx:Cylindrical.radiusSq axis x≤1)
+    (hs:|Cylindrical.axis axis x/CapAlgebra.V (Cylindrical.radiusSq axis x) capB|=3/4) :
+    ‖gradient smoothCap x‖^2≤c7 := by
+  rw [smoothCap_boundary_gradient hx hs]
+  exact cap_boundary_slope_bound
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ClampedFoliationGraph.lean

@@ -0,0 +1,96 @@
+import OAI.Analysis.BernoulliCone.SmoothIntervalPrimitive
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter InnerProductSpace MeasureTheory
+open scoped Topology ContDiff
+namespace Bernoulli.Foliation
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+
+def clampedHeight (u σ v:E→ℝ) (x:E):ℝ:=max (u x) (min (v x) (σ x))
+omit [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] in
+lemma le_clampedHeight [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+    (u σ v:E→ℝ) (x:E):u x≤clampedHeight u σ v x:=le_max_left _ _
+omit [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] in
+lemma clampedHeight_le [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+    {u σ v:E→ℝ} {x:E} (h:u x≤v x):clampedHeight u σ v x≤v x:=
+  max_le h (min_le_left _ _)
+omit [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] in
+lemma below_clampedHeight [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+    {u σ v:E→ℝ} {x:E} {t:ℝ}
+    (hl:u x<t) (ht:t<clampedHeight u σ v x):t<σ x := by
+  have hh:=lt_max_iff.mp ht
+  rcases hh with h|h
+  · exact False.elim ((not_lt.mpr hl.le) h)
+  · exact h.trans_le (min_le_right _ _)
+omit [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] in
+lemma above_clampedHeight [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+    {u σ v:E→ℝ} {x:E} {t:ℝ}
+    (hu:clampedHeight u σ v x<t) (ht:t<v x):σ x<t := by
+  have hh:min (v x) (σ x)<t:=(le_max_right _ _).trans_lt hu
+  exact (min_lt_iff.mp hh).resolve_left (not_lt.mpr ht.le)
+
+omit [FiniteDimensional ℝ E] in
+lemma graphPotential_eq_integral [FiniteDimensional ℝ E]
+    {A:E×ℝ→E} (hA:Continuous A) (u v:E→ℝ) (x:E) :
+    graphPotential A u v x=(2:ℝ) • (∫s in u x..v x,A (x,s)) := by
+  have hc:Continuous (fun s:ℝ=>A (x,s)):=hA.comp (continuous_const.prodMk continuous_id)
+  unfold graphPotential ParametricIntegral.heightPrimitive
+  rw [←intervalIntegral.integral_interval_sub_left (hc.intervalIntegrable 0 (v x))
+    (hc.intervalIntegrable 0 (u x))]
+
+lemma clamped_integral_identity {F A B:E×ℝ→E} (hA:Continuous A) (hB:Continuous B)
+    {u σ v:E→ℝ} {x:E} (huv:u x≤v x)
+    (hFi:∀a b:ℝ,IntervalIntegrable (fun t:ℝ=>F (x,t)) volume a b)
+    (hAe:∀t∈Ioo (u x) (v x),t<σ x → F (x,t)=A (x,t))
+    (hBe:∀t∈Ioo (u x) (v x),σ x<t → F (x,t)=B (x,t)) :
+    (2:ℝ) • (∫s in u x..v x,F (x,s))=
+      splitGraphPotential A B u (clampedHeight u σ v) v x := by
+  let w:=clampedHeight u σ v x
+  have huw:u x≤w:=le_clampedHeight u σ v x
+  have hwv:w≤v x:=clampedHeight_le huv
+  have heA:(∫s in u x..w,F (x,s))=∫s in u x..w,A (x,s):=
+    intervalIntegral.integral_congr_Ioo_of_le huw (fun t ht=>hAe t ⟨ht.1,ht.2.trans_le hwv⟩
+      (below_clampedHeight ht.1 ht.2))
+  have heB:(∫s in w..v x,F (x,s))=∫s in w..v x,B (x,s):=
+    intervalIntegral.integral_congr_Ioo_of_le hwv (fun t ht=>hBe t ⟨huw.trans_lt ht.1,ht.2⟩
+      (above_clampedHeight ht.1 ht.2))
+  rw [splitGraphPotential,graphPotential_eq_integral hA,graphPotential_eq_integral hB]
+  rw [←intervalIntegral.integral_add_adjacent_intervals (hFi (u x) w) (hFi w (v x)),heA,heB,smul_add]
+
+lemma integrated_bulk_open {A:E×ℝ→E} (hA:ContDiff ℝ 1 A) (x:E) {a b:ℝ} (hab:a≤b)
+    (hbulk:∀s∈Ioo a b,divergence (fun y:E=>A (y,s)) x+
+      inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)≤0) :
+    2*(∫s in a..b,divergence (fun y:E=>A (y,s)) x)≤‖A (x,a)‖^2-‖A (x,b)‖^2 := by
+  rcases hab.eq_or_lt with he|hlt
+  · subst b; simp
+  · apply integrated_bulk hA x hab
+    have hAC:ContDiff ℝ 1 (fun s:ℝ=>A (x,s)):=hA.comp (contDiff_const.prodMk contDiff_id)
+    have hc:Continuous (fun s:ℝ=>divergence (fun y:E=>A (y,s)) x+
+        inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)):=
+      (continuous_spatial_divergence hA x).add (hAC.continuous.inner (hAC.continuous_deriv (by norm_num)))
+    exact fun s hs=>le_on_closure hbulk hc.continuousOn continuousOn_const (by rwa [closure_Ioo hlt.ne])
+
+lemma graphPotential_locallyLipschitz {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u v:E→ℝ} (hu:LocallyLipschitz u) (hv:LocallyLipschitz v) :
+    LocallyLipschitz (graphPotential A u v) := by
+  have hh:= (ParametricIntegral.heightPrimitive_contDiff_one hA).locallyLipschitz
+  exact ((2:ℝ) • ContinuousLinearMap.id ℝ E).lipschitzWith.locallyLipschitz.comp
+    ((hh.comp (LocallyLipschitz.id.prodMk hv)).sub (hh.comp (LocallyLipschitz.id.prodMk hu)))
+
+lemma clamped_split_locallyLipschitz {A B:E×ℝ→E} (hA:ContDiff ℝ 1 A) (hB:ContDiff ℝ 1 B)
+    {u σ v:E→ℝ} (hu:LocallyLipschitz u) (hv:LocallyLipschitz v) (hσ:LocallyLipschitz σ) :
+    LocallyLipschitz (splitGraphPotential A B u (clampedHeight u σ v) v) := by
+  have hw:LocallyLipschitz (clampedHeight u σ v):=hu.max (hv.min h��)
+  exact (graphPotential_locallyLipschitz hA hu hw).add (graphPotential_locallyLipschitz hB hw hv)
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ClampedGraphBound.lean

@@ -0,0 +1,87 @@
+import OAI.Analysis.BernoulliCone.ClampedSeam
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter InnerProductSpace MeasureTheory
+open scoped Topology ContDiff
+namespace Bernoulli.Foliation
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+
+lemma gradient_eq_of_order_contact {u v:E→ℝ} {x:E}
+    (hu:DifferentiableAt ℝ u x) (hv:DifferentiableAt ℝ v x)
+    (hle:∀y,u y≤v y) (he:u x=v x) : gradient u x=gradient v x := by
+  have hm:IsLocalMin (fun y=>v y-u y) x:=by
+    filter_upwards [] with y
+    change v x-u x≤v y-u y
+    rw [←he,sub_self]
+    exact sub_nonneg.mpr (hle y)
+  have hh:=hm.hasFDerivAt_eq_zero (hv.hasFDerivAt.sub hu.hasFDerivAt)
+  exact congrArg ((toDual ℝ E).symm) (sub_eq_zero.mp hh).symm
+
+lemma graph_divergence_zero_contact {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u v:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) (hv:DifferentiableAt ℝ v x)
+    (hle:∀y,u y≤v y) (he:u x=v x) : divergence (graphPotential A u v) x=0 := by
+  rw [graph_potential_identity hA hu hv,he,gradient_eq_of_order_contact hu hv hle he]
+  simp
+
+lemma graph_potential_bulk_bound_open {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u v:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) (hv:DifferentiableAt ℝ v x)
+    (huv:u x≤v x)
+    (hbulk:∀s∈Ioo (u x) (v x),divergence (fun y:E=>A (y,s)) x+
+      inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)≤0) :
+    divergence (graphPotential A u v) x≤‖gradient v x‖^2+
+      ‖A (x,u x)‖^2-2*inner ℝ (A (x,u x)) (gradient u x) := by
+  have hi:=integrated_bulk_open hA x huv hbulk
+  have hs:0≤‖gradient v x-A (x,v x)‖^2:=sq_nonneg _
+  have he:inner ℝ (gradient v x) (A (x,v x))=inner ℝ (A (x,v x)) (gradient v x):=real_inner_comm _ _
+  rw [norm_sub_sq_real,he] at hs
+  rw [graph_potential_identity hA hu hv]
+  linarith
+
+/-- The clamped primitive only needs a jump condition when the seam lies
+strictly between the endpoint graphs. On contact sets the two gradients
+agree, so the spurious branch cancels exactly. -/
+lemma split_graph_bound_open {A B:E×ℝ→E} (hA:ContDiff ℝ 1 A) (hB:ContDiff ℝ 1 B)
+    {u w v:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) (hw:DifferentiableAt ℝ w x)
+    (hv:DifferentiableAt ℝ v x) (huw:∀y,u y≤w y) (hwv:∀y,w y≤v y)
+    (hbulkA:∀s∈Ioo (u x) (w x),divergence (fun y:E=>A (y,s)) x+
+      inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)≤0)
+    (hbulkB:∀s∈Ioo (w x) (v x),divergence (fun y:E=>B (y,s)) x+
+      inner ℝ (B (x,s)) (deriv (fun t:ℝ=>B (x,t)) s)≤0)
+    (hjump:u x<w x → w x<v x → ‖B (x,w x)‖^2-‖A (x,w x)‖^2-
+      2*inner ℝ (B (x,w x)-A (x,w x)) (gradient w x)≤0) :
+    divergence (splitGraphPotential A B u w v) x≤‖gradient v x‖^2+
+      ‖(if u x=w x then B else A) (x,u x)‖^2-
+        2*inner ℝ ((if u x=w x then B else A) (x,u x)) (gradient u x) := by
+  have hd:divergence (splitGraphPotential A B u w v) x=
+      divergence (graphPotential A u w) x+divergence (graphPotential B w v) x:=
+    divergence_add (graphPotential_differentiableAt hA hu hw) (graphPotential_differentiableAt hB hw hv)
+  by_cases heu:u x=w x
+  · rw [ite_eq_left heu,hd,graph_divergence_zero_contact hA hu hw huw heu,zero_add]
+    have heG:=gradient_eq_of_order_contact hu hw huw heu
+    simpa only [←heu,←heG] using graph_potential_bulk_bound_open hB hw hv (hwv x) hbulkB
+  · rw [ite_eq_right heu]
+    by_cases hev:w x=v x
+    · rw [hd,graph_divergence_zero_contact hB hw hv hwv hev,add_zero]
+      have heG:=gradient_eq_of_order_contact hw hv hwv hev
+      simpa only [heG] using graph_potential_bulk_bound_open hA hu hw (huw x) hbulkA
+    · have hiA:=integrated_bulk_open hA x (huw x) hbulkA
+      have hiB:=integrated_bulk_open hB x (hwv x) hbulkB
+      have hj:=hjump (lt_of_le_of_ne (huw x) heu) (lt_of_le_of_ne (hwv x) hev)
+      rw [inner_sub_left] at hj
+      have hs:0≤‖gradient v x-B (x,v x)‖^2:=sq_nonneg _
+      have he:inner ℝ (gradient v x) (B (x,v x))=inner ℝ (B (x,v x)) (gradient v x):=real_inner_comm _ _
+      rw [norm_sub_sq_real,he] at hs
+      rw [hd,graph_potential_identity hA hu hw,graph_potential_identity hB hw hv]
+      linarith
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ClampedSeam.lean

@@ -0,0 +1,79 @@
+import OAI.Analysis.BernoulliCone.CompactLipschitzDivergence
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace MeasureTheory
+open scoped Topology ContDiff NNReal
+namespace Bernoulli.DeSilvaJerison
+open Foliation
+lemma clamped_seam_axis {u v:Space 7→ℝ} {x:Space 7} (hu:U x<u x)
+    (hq:Cylindrical.radiusSq axis x=0) : clampedHeight u seamHeight v x=u x := by
+  have hσ:seamHeight x=0:=by rw [seamHeight_formula,hq,Real.sqrt_zero]; ring
+  unfold clampedHeight
+  rw [hσ,max_eq_left ((min_le_right _ _).trans ((U_nonneg x).trans hu.le))]
+
+lemma clamped_seam_le_lower {u v:Space 7→ℝ} {x:Space 7} (hu:U x<u x)
+    (hq:Cylindrical.radiusSq axis ((upperParameter x (u x))⁻¹ • x)<1) :
+    clampedHeight u seamHeight v x=u x := by
+  rcases (Cylindrical.radiusSq_nonneg axis x axis_norm).eq_or_lt with he|hl
+  · exact clamped_seam_axis hu he.symm
+  · have hs:seamHeight x≤u x:=(upperParameter_seam_iff (p:=(x,u x)) hu hl).mp hq.le
+    exact max_eq_left ((min_le_right _ _).trans hs)
+
+theorem clamped_seam_locallyLipschitz {u v:Space 7→ℝ}
+    (hu:LocallyLipschitz u) (hv:LocallyLipschitz v) (huU:∀y,U y<u y) :
+    LocallyLipschitz (clampedHeight u seamHeight v) := by
+  intro x
+  rcases (Cylindrical.radiusSq_nonneg axis x axis_norm).eq_or_lt with he|hl
+  · have hpx:(x,u x)∈{p:Space 7×ℝ|U p.1<p.2 ∧
+        Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)<1}:=by
+      refine ⟨huU x,?_⟩
+      rw [Cylindrical.radiusSq_smul,←he,mul_zero]
+      norm_num
+    have hn:∀ᶠ y in 𝓝 x,Cylindrical.radiusSq axis ((upperParameter y (u y))⁻¹ • y)<1:=
+      ((continuousAt_id.prodMk hu.continuous.continuousAt).eventually (capTube_isOpen.mem_nhds hpx)).mono fun _ h=>h.2
+    obtain ⟨K,V,hV,hL⟩:=hu x
+    refine ⟨K,V∩{y|clampedHeight u seamHeight v y=u y},inter_mem hV (hn.mono fun y hy=>clamped_seam_le_lower (huU y) hy),?_⟩
+    intro y hy z hz
+    rw [hy.2,hz.2]
+    exact hL hy.1 hz.1
+  · obtain ⟨σ,hσ,hσe⟩:=seamHeight_smooth_germ hl
+    have hw:LocallyLipschitz (clampedHeight u σ v):=hu.max (hv.min hσ.locallyLipschitz)
+    obtain ⟨K,V,hV,hL⟩:=hw x
+    refine ⟨K,V∩{y|σ y=seamHeight y},inter_mem hV hσe,?_⟩
+    intro y hy z hz
+    have he1:clampedHeight u seamHeight v y=clampedHeight u σ v y:=by
+      change max (u y) (min (v y) (seamHeight y))=max (u y) (min (v y) (σ y))
+      rw [hy.2]
+    have he2:clampedHeight u seamHeight v z=clampedHeight u σ v z:=by
+      change max (u z) (min (v z) (seamHeight z))=max (u z) (min (v z) (σ z))
+      rw [hz.2]
+    rw [he1,he2]
+    exact hL hy.1 hz.1
+
+lemma clamped_sub_lower_compact {u v:Space 7→ℝ} (h:HasCompactSupport (fun x=>v x-u x)) :
+    HasCompactSupport (fun x=>clampedHeight u seamHeight v x-u x) := by
+  apply HasCompactSupport.intro h
+  intro x hx
+  have hvu:v x=u x:=sub_eq_zero.mp (image_eq_zero_of_notMem_tsupport (f:=fun y=>v y-u y) hx)
+  change max (u x) (min (v x) (seamHeight x))-u x=0
+  rw [hvu,max_eq_left (min_le_left _ _),sub_self]
+
+theorem clamped_seam_lipschitz {u v:Space 7→ℝ} {K L:ℝ≥0}
+    (hu:LipschitzWith K u) (hv:LipschitzWith L v) (huU:∀y,U y<u y)
+    (hc:HasCompactSupport (fun x=>v x-u x)) :
+    ∃M:ℝ≥0,LipschitzWith M (clampedHeight u seamHeight v) := by
+  have hh:=clamped_seam_locallyLipschitz hu.locallyLipschitz hv.locallyLipschitz huU
+  obtain ⟨C,hC⟩:=locallyLipschitz_compact_lipschitz (hh.sub hu.locallyLipschitz) (clamped_sub_lower_compact hc)
+  refine ⟨C+K,?_⟩
+  convert! hC.add hu using 1
+  ext x
+  exact (sub_add_cancel _ _).symm
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ClosedGermExtension.lean

@@ -0,0 +1,50 @@
+import OAI.Analysis.BernoulliCone.SeamHeight
+
+namespace OAI
+
+universe uE uG
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology ContDiff Manifold
+namespace Bernoulli.LocalExtension
+variable {E : Type uE} {G : Type uG} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  [FiniteDimensional ℝ E] [NormedAddCommGroup G] [NormedSpace ℝ G]
+/-- C1 germs agreeing on a closed subset glue to a global C1 extension.
+This is an application of the actual smooth partition of unity, not a Whitney
+extension premise. -/
+lemma exists_contDiff_one_of_closed_germs {S:Set E} (hS:IsClosed S) {F:E→G}
+    (hg:∀x∈S,∃B:E→G,ContDiffAt ℝ 1 B x ∧ ∀ᶠ y in 𝓝 x,y∈S→B y=F y) :
+    ∃B:E→G,ContDiff ℝ 1 B ∧ EqOn B F S := by
+  classical
+  let t:E→Set G:=fun x=>if x∈S then {F x} else univ
+  have ht(x:E):Convex ℝ (t x):=by
+    by_cases hx:x∈S
+    · simpa only [t,ite_eq_left hx] using convex_singleton (F x)
+    · simpa only [t,ite_eq_right hx] using (convex_univ : Convex ℝ (univ:Set G))
+  have hl(x:E):∃U∈𝓝 x,∃g:E→G,ContMDiffOn 𝓘(ℝ,E) 𝓘(ℝ,G) 1 g U ∧
+      ∀y∈U,g y∈t y := by
+    by_cases hx:x∈S
+    · obtain ⟨g,hgc,hge⟩:=hg x hx
+      obtain ⟨V,hV,hgV⟩:=hgc.contDiffOn le_rfl (by norm_num)
+      refine ⟨V∩{y|y∈S → g y=F y},inter_mem hV hge,g,?_,?_⟩
+      · exact (hgV.mono inter_subset_left).contMDiffOn
+      · intro y hy
+        by_cases hyS:y∈S
+        · simp only [t,ite_eq_left hyS,mem_singleton_iff]
+          exact hy.2 hyS
+        · simp only [t,ite_eq_right hyS,mem_univ]
+    · refine ⟨Sᶜ,hS.isOpen_compl.mem_nhds hx,fun _=>0,contMDiffOn_const,?_⟩
+      intro y hy
+      simp only [t,ite_eq_right hy,mem_univ]
+  obtain ⟨B,hB⟩:=exists_contMDiffMap_forall_mem_convex_of_local 𝓘(ℝ,E) ht hl
+  refine ⟨B,B.contMDiff.contDiff,?_⟩
+  intro x hx
+  simpa only [t,ite_eq_left hx,mem_singleton_iff] using hB x
+end Bernoulli.LocalExtension
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CompactGradient.lean

@@ -0,0 +1,42 @@
+import OAI.Analysis.BernoulliCone.HalfspaceDifferential
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli
+open scoped _root_.Bernoulli
+variable {d : ℕ}
+
+lemma integral_gradient_compact {q : Space d → ℝ} {K : ℝ≥0}
+    (hq : LipschitzWith K q) (hc : HasCompactSupport q) (e : Space d) :
+    (∫ x, inner ℝ (gradient q x) e) = 0 := by
+  have hh := (LipschitzWith.const (1:ℝ)).integral_lineDeriv_mul_eq
+    (μ:=volume) hq hc (-e)
+  have he : (fun x => lineDeriv ℝ q x (-(-e)) * (1:ℝ)) =ᵐ[volume]
+      (fun x => inner ℝ (gradient q x) e) := by
+    filter_upwards [hq.ae_differentiableAt] with x hx
+    simp only [neg_neg,mul_one,hx.lineDeriv_eq_fderiv,inner_gradient_left]
+  rw [integral_congr_ae he] at hh
+  have hz (x : Space d) : lineDeriv ℝ (fun _ : Space d => (1:ℝ)) x (-e)=0 := by
+    rw [(differentiableAt_const (1:ℝ)).lineDeriv_eq_fderiv]
+    simp
+  simpa only [hz,zero_mul,integral_zero] using hh.symm
+
+lemma setIntegral_gradient_compact {q : Space d → ℝ} {K : ℝ≥0}
+    (hq : LipschitzWith K q) (hc : HasCompactSupport q)
+    {D : Set (Space d)} (hD : tsupport q ⊆ D) (e : Space d) :
+    (∫ x in D, inner ℝ (gradient q x) e) = 0 := by
+  rw [setIntegral_eq_integral_of_forall_compl_eq_zero]
+  · exact integral_gradient_compact hq hc e
+  · intro x hx
+    have hn : x∉tsupport q := fun hh => hx (hD hh)
+    simp [gradient,fderiv_of_notMem_tsupport ℝ hn]
+end Bernoulli
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CompactLipschitzDivergence.lean

@@ -0,0 +1,149 @@
+import OAI.Analysis.BernoulliCone.FluxSeam
+
+namespace OAI
+
+universe uE uG
+
+section
+noncomputable section
+open MeasureTheory Set Filter InnerProductSpace
+open scoped Topology ContDiff NNReal
+namespace Bernoulli.Foliation
+variable {E : Type uE} {G : Type uG} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
+  [NormedAddCommGroup G] [NormedSpace ℝ G]
+
+omit [NormedSpace ℝ G] in
+lemma locallyLipschitz_compact_lipschitz [NormedSpace ℝ G] {F:E→G} (hl:LocallyLipschitz F)
+    (hc:HasCompactSupport F) : ∃K:ℝ≥0,LipschitzWith K F := by
+  obtain ⟨R,hR⟩:=hc.isBounded.subset_ball (0:E)
+  obtain ⟨K,hK⟩:=hl.locallyLipschitzOn.exists_lipschitzOnWith_of_compact
+    (isCompact_closedBall (0:E) (R+1))
+  obtain ⟨M,hM⟩:=hc.exists_bound_of_continuousOn hl.continuous.continuousOn
+  let C:ℝ≥0:=⟨max (K:ℝ) (max M 0),le_max_of_le_right (le_max_right _ _)⟩
+  have hKC:(K:ℝ)≤C:=le_max_left _ _
+  have hMC:M≤(C:ℝ):=(le_max_left M 0).trans (le_max_right _ _)
+  have hbound (x y:E) (hx:x∈tsupport F) (hy:y∉Metric.closedBall (0:E) (R+1)):
+      dist (F x) (F y)≤(C:ℝ)*dist x y := by
+    have hFx:dist x 0<R:=hR hx
+    have hFy:R+1<dist y 0:=by simpa only [Metric.mem_closedBall,not_le] using hy
+    have hdy:1≤dist x y:=by have hh:=dist_triangle y x 0; rw [dist_comm y x] at hh; linarith
+    have hyS:y∉tsupport F:=by
+      intro hys
+      have hyR:=hR hys
+      change dist y 0<R at hyR
+      linarith
+    rw [image_eq_zero_of_notMem_tsupport hyS,dist_zero_right]
+    exact (hM x hx).trans (hMC.trans (le_mul_of_one_le_right C.2 hdy))
+  refine ⟨C,LipschitzWith.of_dist_le_mul fun x y=>?_⟩
+  by_cases hx:x∈tsupport F
+  · by_cases hy:y∈Metric.closedBall (0:E) (R+1)
+    · have hxB:x∈Metric.closedBall (0:E) (R+1):=by
+        have hh:=hR hx
+        change dist x 0<R at hh
+        change dist x 0≤R+1
+        linarith
+      exact (hK.dist_le_mul x hxB y hy).trans (mul_le_mul_of_nonneg_right hKC dist_nonneg)
+    · exact hbound x y hx hy
+  · by_cases hy:y∈tsupport F
+    · by_cases hxB:x∈Metric.closedBall (0:E) (R+1)
+      · have hyB:y∈Metric.closedBall (0:E) (R+1):=by
+          have hh:=hR hy
+          change dist y 0<R at hh
+          change dist y 0≤R+1
+          linarith
+        exact (hK.dist_le_mul x hxB y hyB).trans (mul_le_mul_of_nonneg_right hKC dist_nonneg)
+      · simpa only [dist_comm] using hbound y x hy hxB
+    · rw [image_eq_zero_of_notMem_tsupport hx,image_eq_zero_of_notMem_tsupport hy,dist_self]
+      positivity
+
+lemma integral_directional_compact {d:ℕ} {f:Space d→ℝ} {K:ℝ≥0}
+    (hf:LipschitzWith K f) (hc:HasCompactSupport f) (v:Space d) :
+    (∫x,fderiv ℝ f x v)=0 := by
+  obtain ⟨φ,hφ,hφc,hφS,hφ1⟩:=LocalExtension.exists_cutoff hc isOpen_univ (subset_univ _)
+  have hφT:Test univ φ:=⟨hφ,hφc,hφS⟩
+  have hh:=LipschitzSobolev.weakGradient hf univ φ hφT v
+  simp only [Measure.restrict_univ,inner_gradient_left] at hh
+  have hr:(fun x:Space d=>fderiv ℝ f x v * φ x)=(fun x=>fderiv ℝ f x v):=by
+    funext x
+    by_cases hx:x∈tsupport f
+    · have he:φ x=1:=(show φ =ᶠ[𝓝 x] (fun _=>1) from hφ1.filter_mono (nhds_le_nhdsSet hx)).self_of_nhds
+      rw [he,mul_one]
+    · rw [fderiv_of_notMem_tsupport ℝ hx,zero_apply,zero_mul]
+  have he:(fun x:Space d=>f x*(fderiv ℝ φ x) v)=0:=by
+    funext x
+    by_cases hx:x∈tsupport f
+    · have heq:φ =ᶠ[𝓝 x] (fun _=>1):=hφ1.filter_mono (nhds_le_nhdsSet hx)
+      simp only [heq.fderiv_eq,fderiv_fun_const,zero_apply,mul_zero,Pi.zero_apply]
+    · rw [image_eq_zero_of_notMem_tsupport hx,zero_mul]
+      rfl
+  rw [hr,he] at hh
+  simpa only [integral_zero,Pi.zero_def,zero_eq_neg] using hh
+lemma integrable_directional_compact {d:ℕ} {f:Space d→ℝ} {K:ℝ≥0}
+    (hf:LipschitzWith K f) (hc:HasCompactSupport f) (v:Space d) :
+    Integrable (fun x=>fderiv ℝ f x v) := by
+  have hs:Function.support (fun x=>fderiv ℝ f x v)⊆tsupport f:=
+    (subset_tsupport _).trans (tsupport_fderiv_apply_subset ℝ v)
+  apply (integrableOn_iff_integrable_of_support_subset hs).mp
+  apply (integrableOn_const (μ:=volume) (C:=((K:ℝ)*‖v‖)) hc.measure_ne_top).mono'
+    (((continuous_id.clm_apply continuous_const : Continuous (fun L:Space d→L[ℝ]ℝ=>L v)).measurable.comp (measurable_fderiv ℝ f)).aestronglyMeasurable.restrict)
+  filter_upwards [] with x
+  exact ((fderiv ℝ f x).le_opNorm v).trans
+    (mul_le_mul_of_nonneg_right (norm_fderiv_le_of_lipschitz ℝ hf) (norm_nonneg v))
+
+lemma integrable_divergence_compact {d:ℕ} {F:Space d→Space d} {K:ℝ≥0}
+    (hF:LipschitzWith K F) (hc:HasCompactSupport F) : Integrable (divergence F) := by
+  let e:=stdOrthonormalBasis ℝ (Space d)
+  let f:=fun i x=>inner ℝ (e i) (F x)
+  have hf i:LipschitzWith (‖innerSL ℝ (e i)‖₊*K) (f i):=
+    (innerSL ℝ (e i)).lipschitzWith.comp hF
+  have hfc i:HasCompactSupport (f i):=by
+    apply HasCompactSupport.intro hc
+    intro x hx
+    simp only [f,image_eq_zero_of_notMem_tsupport hx,inner_zero_right]
+  have he:divergence F =ᵐ[volume] (fun x=>∑i,fderiv ℝ (f i) x (e i)):=by
+    filter_upwards [hF.ae_differentiableAt] with x hx
+    unfold divergence
+    apply Finset.sum_congr rfl
+    intro i hi
+    have hd:HasFDerivAt (f i) ((innerSL ℝ (e i)) ∘L fderiv ℝ F x) x:=
+      (innerSL ℝ (e i)).hasFDerivAt.comp x hx.hasFDerivAt
+    rw [hd.fderiv]
+    rfl
+  exact (integrable_finsetSum _ (fun i hi=>integrable_directional_compact (hf i) (hfc i) (e i))).congr he.symm
+
+lemma divergence_zero_outside_support {d:ℕ} {F:Space d→Space d} {x:Space d}
+    (hx:x∉tsupport F) : divergence F x=0 := by
+  unfold divergence
+  simp only [fderiv_of_notMem_tsupport ℝ hx,zero_apply,inner_zero_right,
+    Finset.sum_const_zero]
+
+/-- The divergence of a genuine compactly supported Lipschitz vector field
+has integral zero, with the a.e. derivative justified by Rademacher. -/
+theorem integral_divergence_compact {d:ℕ} {F:Space d→Space d} {K:ℝ≥0}
+    (hF:LipschitzWith K F) (hc:HasCompactSupport F) :
+    (∫x,divergence F x)=0 := by
+  let e:=stdOrthonormalBasis ℝ (Space d)
+  let f:=fun i x=>inner ℝ (e i) (F x)
+  have hf i:LipschitzWith (‖innerSL ℝ (e i)‖₊*K) (f i):=
+    (innerSL ℝ (e i)).lipschitzWith.comp hF
+  have hfc i:HasCompactSupport (f i):=by
+    apply HasCompactSupport.intro hc
+    intro x hx
+    simp only [f,image_eq_zero_of_notMem_tsupport hx,inner_zero_right]
+  have he:divergence F =ᵐ[volume] (fun x=>∑i,fderiv ℝ (f i) x (e i)):=by
+    filter_upwards [hF.ae_differentiableAt] with x hx
+    unfold divergence
+    apply Finset.sum_congr rfl
+    intro i hi
+    have hd:HasFDerivAt (f i) ((innerSL ℝ (e i)) ∘L fderiv ℝ F x) x:=
+      (innerSL ℝ (e i)).hasFDerivAt.comp x hx.hasFDerivAt
+    rw [hd.fderiv]
+    rfl
+  rw [integral_congr_ae he,integral_finsetSum _ (fun i hi=>integrable_directional_compact (hf i) (hfc i) (e i))]
+  simp only [integral_directional_compact (hf _) (hfc _),Finset.sum_const_zero]
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CompactZeroFiber.lean

@@ -0,0 +1,33 @@
+import OAI.Analysis.BernoulliCone.PositiveTrace
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology
+namespace Bernoulli.Foliation
+variable {E : Type uE} [TopologicalSpace E]
+/-- Compact zero-fiber control. No convergence of the selected root is needed. -/
+lemma eventually_near_zero_fiber {K:Set E} (hK:IsCompact K) {f g:E→ℝ} {C:ℝ}
+    (hf:∀x∈K,ContinuousAt f x) (hg:∀x∈K,ContinuousAt g x)
+    (hzero:∀x∈K,f x=0 → g x<C) :
+    ∀ᶠ t:ℝ in 𝓝 0,∀x∈K,f x=t → g x<C := by
+  apply hK.eventually_forall_of_forall_eventually
+  intro x hx
+  by_cases hz:f x=0
+  · have hh:∀ᶠ p:ℝ×E in 𝓝 (0,x),g p.2<C:=
+      ((hg x hx).comp continuous_snd.continuousAt).eventually (gt_mem_nhds (hzero x hx hz))
+    exact hh.mono fun p hp _=>hp
+  · have hn:f x-(0:ℝ)≠0:=by simpa using hz
+    have hh:∀ᶠ p:ℝ×E in 𝓝 (0,x),f p.2-p.1≠0:=
+      (((hf x hx).comp continuous_snd.continuousAt).sub continuous_fst.continuousAt).eventually_ne hn
+    exact hh.mono fun p hp he=>False.elim (hp (sub_eq_zero.mpr he))
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ConePicone.lean

@@ -0,0 +1,134 @@
+import OAI.Analysis.BernoulliCone.DominatedVariation
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli.Halfspace
+open HarmonicKernel
+variable {d : ℕ}
+
+lemma positiveSquareRatio_hasFDerivAt {u v : Space d → ℝ} {x : Space d}
+    (hu : DifferentiableAt ℝ u x) (hv : DifferentiableAt ℝ v x) (hu0 : 0<u x) :
+    HasFDerivAt (positiveSquareRatio v u)
+      ((2*v x/u x) • fderiv ℝ v x-(v x/u x)^2 • fderiv ℝ u x) x := by
+  have hh := (hv.hasFDerivAt.pow 2).mul ((hasDerivAt_inv hu0.ne').comp_hasFDerivAt x hu.hasFDerivAt)
+  have he : positiveSquareRatio v u =ᶠ[𝓝 x] (fun y=>v y^2/u y) := by
+    filter_upwards [hu.continuousAt.preimage_mem_nhds (Ioi_mem_nhds hu0)] with y hy
+    change 0<u y at hy
+    simp only [positiveSquareRatio,ite_eq_left hy]
+  simp only [Function.comp_apply] at hh
+  convert! hh.congr_of_eventuallyEq he using 1
+  ext z
+  simp only [sub_apply,smul_apply,smul_eq_mul,add_apply,pow_one,Nat.reduceSub]
+  field_simp
+  ring
+
+lemma positiveSquareRatio_gradient {u v : Space d → ℝ} {x : Space d}
+    (hu : DifferentiableAt ℝ u x) (hv : DifferentiableAt ℝ v x) (hu0 : 0<u x) :
+    gradient (positiveSquareRatio v u) x=
+      (2*v x/u x) • gradient v x-(v x/u x)^2 • gradient u x := by
+  apply ext_inner_right ℝ
+  intro z
+  rw [inner_gradient_left,(positiveSquareRatio_hasFDerivAt hu hv hu0).fderiv]
+  simp only [sub_apply,smul_apply,smul_eq_mul,inner_sub_left,real_inner_smul_left,inner_gradient_left]
+
+lemma weighted_positiveSquareRatio_gradient {u v : Space d → ℝ} {x : Space d}
+    (hu : DifferentiableAt ℝ u x) (hv : DifferentiableAt ℝ v x) (hu0 : 0<u x) :
+    gradient (fun y=>potential y*positiveSquareRatio v u y) x =
+      positiveSquareRatio v u x • gradient potential x +
+        potential x • gradient (positiveSquareRatio v u) x := by
+  apply ext_inner_right ℝ
+  intro z
+  have hh := (contDiff_potential.differentiable (by simp) x).hasFDerivAt.mul
+    (positiveSquareRatio_hasFDerivAt hu hv hu0)
+  change HasFDerivAt (fun y=>potential y*positiveSquareRatio v u y) _ x at hh
+  rw [inner_gradient_left,hh.fderiv]
+  simp only [inner_add_left,real_inner_smul_left,inner_gradient_left,add_apply,smul_apply,smul_eq_mul]
+  rw [(positiveSquareRatio_hasFDerivAt hu hv hu0).fderiv]
+  ring
+
+/-- Picone ground-state equality from full minimizing comparison. It is a
+consequence, not a stationarity or regularity assumption in `GlobalMinimizer`. -/
+theorem picone_gradient_equality {u v : Space d → ℝ} {L M C : ℝ≥0}
+    (hm : GlobalMinimizer u) (hL : LipschitzWith L u) (hM : LipschitzWith M v)
+    (hom : ∀r:ℝ, 0<r → ∀x, u (r•x)=r*u x)
+    (hC : 1≤C) (hbound : ∀x, |v x| ≤ (C:ℝ)*u x)
+    (hvI : (∫ x in ball (0:Space d) 2, potential x*‖gradient v x‖^2-rawKernel x*v x^2)=0) :
+    ∀ᵐ x ∂volume.restrict (ball (0:Space d) 1),
+      gradient v x=(v x/u x) • gradient u x := by
+  let B := ball (0:Space d) 2
+  let μ := volume.restrict B
+  let : IsFiniteMeasure μ := isFiniteMeasure_restrict.mpr measure_ball_lt_top.ne
+  have hn := hm.nonneg_of_continuous hL.continuous
+  let q := fun x=>potential x*positiveSquareRatio v u x
+  have hφ : Test B potential := radial_potential_test
+  obtain ⟨K,hφL⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hφ.2.1 hφ.1 (by simp)
+  obtain ⟨J,hq'⟩ := lipschitz_mul_compact (positiveSquareRatio_lipschitz hL hM hC hn hbound) hφL hφ.2.1
+  have hq : LipschitzWith J q := by simpa only [q,mul_comm] using hq'
+  have hc : HasCompactSupport q := hφ.2.1.mul_right
+  have hs : tsupport q ⊆ B := tsupport_mul_subset_left.trans hφ.2.2
+  obtain ⟨A,hA⟩ := hφ.2.1.exists_bound_of_continuous contDiff_potential.continuous
+  have hC0 : 0<(C:ℝ) := lt_of_lt_of_le zero_lt_one (show 1≤(C:ℝ) from hC)
+  have hqbound : ∀x, |q x| ≤ ((|A|+1)*(C:ℝ)^2)*u x := by
+    intro x
+    rw [show q x=potential x*positiveSquareRatio v u x from rfl,abs_mul,
+      abs_of_nonneg (positiveSquareRatio_nonneg x)]
+    have hb := positiveSquareRatio_bound C.coe_nonneg hn hbound x
+    have hφb : |potential x| ≤ |A|+1 := (hA x).trans (by linarith [le_abs_self A])
+    calc
+      _ ≤ (|A|+1)*((C:ℝ)^2*u x) := mul_le_mul hφb hb (positiveSquareRatio_nonneg x) (by positivity)
+      _ = _ := by ring
+  have hqI := hm.dominatedVariation hL (by norm_num : 0<(2:ℝ))
+    (LipschitzSobolev.h10 hq hc isOpen_ball hs)
+    (show 0<(|A|+1)*(C:ℝ)^2 by positivity) (Eventually.of_forall hqbound)
+  have hu0 := SobolevCalculus.gradient_zero_on_zero_set isOpen_ball (LipschitzSobolev.h1_ball hL 0 2)
+  have hv0 := SobolevCalculus.gradient_zero_on_zero_set isOpen_ball (LipschitzSobolev.h1_ball hM 0 2)
+  have hq0 := SobolevCalculus.gradient_zero_on_zero_set isOpen_ball (LipschitzSobolev.h1_ball hq 0 2)
+  let F := fun x=>potential x*‖gradient v x‖^2-rawKernel x*v x^2
+  let E := fun x=>inner ℝ (gradient u x) (gradient q x)
+  let R := fun x=>potential x*‖gradient v x-(v x/u x) ��� gradient u x‖^2
+  have hRE : R =ᵐ[μ] (fun x=>F x-E x) := by
+    filter_upwards [ae_restrict_of_ae hL.ae_differentiableAt,
+      ae_restrict_of_ae hM.ae_differentiableAt,hu0,hv0,hq0] with x hux hvx hug hvg hqg
+    by_cases hup : 0<u x
+    · have he := ConeCalculus.euler_identity hux hom
+      rw [←inner_gradient_left] at he
+      dsimp [R,F,E,q]
+      rw [weighted_positiveSquareRatio_gradient hux hvx hup,
+        positiveSquareRatio_gradient hux hvx hup,potential_gradient]
+      rw [←real_inner_self_eq_norm_sq]
+      simp only [inner_sub_left,inner_sub_right,real_inner_smul_left,real_inner_smul_right,
+        inner_add_right,real_inner_self_eq_norm_sq,positiveSquareRatio,ite_eq_left hup,
+        real_inner_comm (gradient v x) (gradient u x),he,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs]
+      field_simp
+      ring
+    · have huz : u x=0 := le_antisymm (not_lt.mp hup) (hn x)
+      have hvz : v x=0 := abs_eq_zero.mp (le_antisymm (by simpa only [huz,mul_zero] using hbound x) (abs_nonneg _))
+      have hqz : q x=0 := by simp [q,positiveSquareRatio,hup]
+      simp only [R,F,E,huz,hvz,hug huz,hvg hvz,hqg hqz,zero_div,zero_smul,sub_self,
+        norm_zero,zero_pow (by norm_num : 2≠0),mul_zero,inner_zero_left]
+  have hFi : Integrable F μ := radial_outer_integrable hM
+  have hEi : Integrable E μ := integrable_inner_of_memLp (LipschitzSobolev.h1_ball hL 0 2).2.1
+    (LipschitzSobolev.h1_ball hq 0 2).2.1
+  have hRi : Integrable R μ := (hFi.sub hEi).congr hRE.symm
+  have hRI : (∫ x, R x ∂μ)=0 := by
+    rw [integral_congr_ae hRE,integral_sub hFi hEi]
+    change (∫x in B,F x)-(∫x in B,E x)=0
+    rw [hvI,hqI,sub_self]
+  have haz : R =ᵐ[μ] 0 := (integral_eq_zero_iff_of_nonneg_ae
+    (Eventually.of_forall (fun x=>mul_nonneg (potential_nonneg x) (sq_nonneg _))) hRi).mp hRI
+  have hle : volume.restrict (ball (0:Space d) 1)≤μ :=
+    Measure.restrict_mono (ball_subset_ball (by norm_num)) le_rfl
+  filter_upwards [ae_mono hle haz,ae_restrict_mem measurableSet_ball] with x hx hxb
+  have hsq : ‖gradient v x-(v x/u x) • gradient u x‖^2=0 :=
+    (mul_eq_zero.mp hx).resolve_left (potential_pos hxb).ne'
+  exact sub_eq_zero.mp (norm_eq_zero.mp (sq_eq_zero_iff.mp hsq))
+end Bernoulli.Halfspace
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/CylindricalCalculus.lean

@@ -0,0 +1,195 @@
+import OAI.Analysis.BernoulliCone.ScalarLaplacian
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter Finset
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.Cylindrical
+open ScalarLaplacian
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+def axis (e x:E) : ℝ := inner ℝ x e
+def transverse (e x:E) : E := x-axis e x • e
+def radiusSq (e x:E) : ℝ := ‖x‖^2-(axis e x)^2
+
+omit [FiniteDimensional ℝ E] in
+theorem transverse_inner [FiniteDimensional ℝ E] (e x:E) (he:‖e‖=1) : inner ℝ (transverse e x) e=0 := by
+  simp [transverse,axis,inner_sub_left,real_inner_smul_left,he]
+omit [FiniteDimensional ℝ E] in
+theorem transverse_sq [FiniteDimensional ℝ E] (e x:E) (he:‖e‖=1) : ‖transverse e x‖^2=radiusSq e x := by
+  rw [transverse,norm_sub_sq_real,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,he,
+    real_inner_smul_right]
+  unfold radiusSq axis
+  ring
+lemma radiusSq_nonneg (e x:E) (he:‖e‖=1) : 0≤radiusSq e x := by
+  rw [←transverse_sq e x he]; positivity
+omit [FiniteDimensional ℝ E] in
+lemma axis_contDiff [FiniteDimensional ℝ E] (e:E) {n:WithTop ℕ∞} : ContDiff ℝ n (axis e) := contDiff_id.inner ℝ contDiff_const
+lemma radiusSq_contDiff (e:E) {n:WithTop ℕ∞} : ContDiff ℝ n (radiusSq e) :=
+  (contDiff_norm_sq (𝕜:=ℝ) (E:=E) (n:=n)).sub ((axis_contDiff e).pow 2)
+lemma gradient_axis (e x:E) : gradient (axis e) x=e := by
+  apply ext_inner_right ℝ
+  intro v
+  rw [←line_deriv (axis_contDiff e (n:=1) |>.differentiable (by norm_num) x) v]
+  have hh:=Axisymmetric.hasDerivAt_axis x v e 0
+  change deriv (fun t:ℝ=>inner ℝ (x+t • v) e) 0 = _
+  rw [hh.deriv,real_inner_comm]
+lemma gradient_norm_sq (x:E) : gradient (fun z:E=>‖z‖^2) x=(2:ℝ) • x := by
+  apply ext_inner_right ℝ
+  intro v
+  rw [←line_deriv (contDiff_norm_sq (𝕜:=ℝ) (E:=E) (n:=1) |>.differentiable (by norm_num) x) v]
+  have hl : HasDerivAt (fun t:ℝ=>x+t • v) v 0 := by
+    simpa using ((hasDerivAt_id (0:ℝ)).smul_const v).const_add x
+  rw [hl.norm_sq.deriv]
+  simp [real_inner_smul_left]
+lemma laplacian_axis (e x:E) : Δ (axis e) x=0 := by
+  rw [laplacian_sum_line (axis_contDiff e).contDiffAt]
+  apply Finset.sum_eq_zero
+  intro i hi
+  have hh : deriv (fun t:ℝ=>axis e (x+t • stdOrthonormalBasis ℝ E i))=
+      fun _=>inner ℝ (stdOrthonormalBasis ℝ E i) e := by
+    funext t; exact (Axisymmetric.hasDerivAt_axis x _ e t).deriv
+  rw [hh,deriv_const]
+lemma laplacian_norm_sq (x:E) : Δ (fun z:E=>‖z‖^2) x=2*(Module.finrank ℝ E : ℝ) := by
+  rw [laplacian_sum_line (contDiff_norm_sq (𝕜:=ℝ) (E:=E) (n:=2)).contDiffAt]
+  have hh (v:E) : deriv (deriv (fun t:ℝ=>‖x+t • v‖^2)) 0=2*‖v‖^2 := by
+    have hl (t:ℝ) : HasDerivAt (fun s:ℝ=>x+s • v) v t := by
+      simpa using ((hasDerivAt_id t).smul_const v).const_add x
+    have he : deriv (fun t:ℝ=>‖x+t • v‖^2)=fun t=>2*inner ℝ (x+t • v) v := by
+      funext t; exact (hl t).norm_sq.deriv
+    rw [he]
+    have hd:=((hl 0).inner ℝ (hasDerivAt_const (0:ℝ) v)).const_mul 2
+    simpa using hd.deriv
+  simp_rw [hh]
+  simp [mul_comm]
+lemma gradient_radiusSq (e x:E) : gradient (radiusSq e) x=(2:ℝ) • transverse e x := by
+  have ha := (axis_contDiff e (n:=1)).differentiable (by norm_num) x
+  have hn := (contDiff_norm_sq (𝕜:=ℝ) (E:=E) (n:=1)).differentiable (by norm_num) x
+  apply ext_inner_right ℝ
+  intro v
+  rw [inner_gradient_left]
+  change (fderiv ℝ (fun z:E=>‖z‖^2-(axis e z)^2) x) v = _
+  have hh:=hn.hasFDerivAt.sub (ha.hasFDerivAt.pow 2)
+  change (fderiv ℝ ((fun z:E=>‖z‖^2)-(fun z:E=>(axis e z)^2)) x) v = _
+  rw [hh.fderiv]
+  simp only [sub_apply,smul_apply]
+  rw [←inner_gradient_left,gradient_norm_sq,←inner_gradient_left,gradient_axis]
+  dsimp [transverse]
+  simp only [real_inner_smul_left,inner_sub_left]
+  ring
+lemma laplacian_radiusSq (e x:E) (he:‖e‖=1) : Δ (radiusSq e) x=2*((Module.finrank ℝ E : ℝ)-1) := by
+  have hφ : ContDiffAt ℝ 2 (fun s:ℝ=>s^2) (axis e x) := contDiffAt_id.pow 2
+  have hh:=laplacian_comp hφ (axis_contDiff e).contDiffAt
+  have hder : deriv (fun s:ℝ=>s^2) = fun s=>2*s := by funext s; simp
+  have hder2 : deriv (deriv (fun s:ℝ=>s^2)) (axis e x)=2 := by rw [hder]; simp
+  rw [hder2,gradient_axis,he,laplacian_axis] at hh
+  change Δ ((fun z:E=>‖z‖^2)-(fun z:E=>(axis e z)^2)) x = _
+  rw [(contDiff_norm_sq (𝕜:=ℝ) (E:=E) (n:=2)).contDiffAt.laplacian_sub ((axis_contDiff e).pow 2).contDiffAt,
+    laplacian_norm_sq,hh]
+  ring
+
+/-- A smooth cylindrical cap, expressed using the squared transverse radius so
+that the symmetry axis is included without a singular-coordinate convention. -/
+def lift (e:E) (y k h:ℝ→ℝ) (x:E) : ℝ := y (radiusSq e x)*h (axis e x*k (radiusSq e x))
+lemma contDiffAt_lift {e x:E} {y k h:ℝ→ℝ} {n:WithTop ℕ∞}
+    (hy:ContDiffAt ℝ n y (radiusSq e x)) (hk:ContDiffAt ℝ n k (radiusSq e x))
+    (hh:ContDiffAt ℝ n h (axis e x*k (radiusSq e x))) : ContDiffAt ℝ n (lift e y k h) x := by
+  exact (hy.comp x (radiusSq_contDiff e).contDiffAt).mul
+    (hh.comp x ((axis_contDiff e).contDiffAt.mul (hk.comp x (radiusSq_contDiff e).contDiffAt)))
+
+lemma gradient_lift {e x:E} {y k h:ℝ→ℝ}
+    (hy:DifferentiableAt ℝ y (radiusSq e x)) (hk:DifferentiableAt ℝ k (radiusSq e x))
+    (hh:DifferentiableAt ℝ h (axis e x*k (radiusSq e x))) :
+    gradient (lift e y k h) x =
+      (2*deriv y (radiusSq e x)*h (axis e x*k (radiusSq e x))) • transverse e x+
+      (y (radiusSq e x)*deriv h (axis e x*k (radiusSq e x))) •
+        (k (radiusSq e x) • e+(2*axis e x*deriv k (radiusSq e x)) • transverse e x) := by
+  have hq: DifferentiableAt ℝ (radiusSq e) x :=
+    (radiusSq_contDiff e (n:=1)).differentiable (by norm_num) x
+  have ha: DifferentiableAt ℝ (axis e) x :=
+    (axis_contDiff e (n:=1)).differentiable (by norm_num) x
+  have hyq : DifferentiableAt ℝ (fun z=>y (radiusSq e z)) x := hy.comp x hq
+  have hkq : DifferentiableAt ℝ (fun z=>k (radiusSq e z)) x := hk.comp x hq
+  have hs : DifferentiableAt ℝ (fun z=>axis e z*k (radiusSq e z)) x := ha.mul hkq
+  have hhs : DifferentiableAt ℝ (fun z=>h (axis e z*k (radiusSq e z))) x := hh.comp x hs
+  change gradient (fun z=>y (radiusSq e z)*h (axis e z*k (radiusSq e z))) x=_
+  rw [gradient_mul hyq hhs,gradient_comp hy hq,gradient_comp (f:=fun z:E=>axis e z*k (radiusSq e z)) hh hs,
+    gradient_mul ha hkq,gradient_comp hk hq,gradient_radiusSq,gradient_axis]
+  simp only [smul_smul]
+  module
+
+lemma laplacian_lift {e x:E} (he:‖e‖=1) {y k h:ℝ→ℝ}
+    (hy:ContDiffAt ℝ 2 y (radiusSq e x)) (hk:ContDiffAt ℝ 2 k (radiusSq e x))
+    (hh:ContDiffAt ℝ 2 h (axis e x*k (radiusSq e x))) :
+    Δ (lift e y k h) x =
+      y (radiusSq e x)*deriv (deriv h) (axis e x*k (radiusSq e x))*
+        ((k (radiusSq e x))^2+4*radiusSq e x*(axis e x)^2*(deriv k (radiusSq e x))^2)+
+      deriv h (axis e x*k (radiusSq e x))*
+        (axis e x*y (radiusSq e x)*(4*radiusSq e x*deriv (deriv k) (radiusSq e x)+
+          2*((Module.finrank ℝ E:ℝ)-1)*deriv k (radiusSq e x))+
+          8*radiusSq e x*axis e x*deriv y (radiusSq e x)*deriv k (radiusSq e x))+
+      h (axis e x*k (radiusSq e x))*(4*radiusSq e x*deriv (deriv y) (radiusSq e x)+
+        2*((Module.finrank ℝ E:ℝ)-1)*deriv y (radiusSq e x)) := by
+  let q := radiusSq e
+  let a := axis e
+  let Y := fun z=>y (q z)
+  let K := fun z=>k (q z)
+  let s := fun z=>a z*K z
+  have hq : ContDiffAt ℝ 2 q x := (radiusSq_contDiff e).contDiffAt
+  have ha : ContDiffAt ℝ 2 a x := (axis_contDiff e).contDiffAt
+  have hY : ContDiffAt ℝ 2 Y x := hy.comp x hq
+  have hK : ContDiffAt ℝ 2 K x := hk.comp x hq
+  have hs : ContDiffAt ℝ 2 s x := ha.mul hK
+  have gY : gradient Y x=deriv y (q x) • ((2:ℝ) • transverse e x) := by
+    rw [gradient_comp (hy.differentiableAt (by norm_num)) (hq.differentiableAt (by norm_num))]
+    rw [show gradient q x=(2:ℝ) • transverse e x from gradient_radiusSq e x]
+  have gK : gradient K x=deriv k (q x) • ((2:ℝ) • transverse e x) := by
+    rw [gradient_comp (hk.differentiableAt (by norm_num)) (hq.differentiableAt (by norm_num))]
+    rw [show gradient q x=(2:ℝ) • transverse e x from gradient_radiusSq e x]
+  have gs : gradient s x=K x • e+(a x*deriv k (q x)*2) • transverse e x := by
+    rw [gradient_mul (ha.differentiableAt (by norm_num)) (hK.differentiableAt (by norm_num)),gK]
+    rw [show gradient a x=e from gradient_axis e x]
+    simp [smul_smul,mul_assoc]
+  have gn : ‖gradient q x‖^2=4*q x := by
+    rw [show gradient q x=(2:ℝ) • transverse e x from gradient_radiusSq e x,norm_smul,mul_pow,
+      Real.norm_eq_abs,transverse_sq e x he]
+    norm_num [q]
+  have gort : inner ℝ e (transverse e x)=0 := by rw [real_inner_comm,transverse_inner e x he]
+  have gsn : ‖gradient s x‖^2=(K x)^2+4*q x*(a x)^2*(deriv k (q x))^2 := by
+    rw [gs,norm_add_sq_real]
+    simp only [norm_smul,mul_pow,Real.norm_eq_abs,sq_abs,he,mul_one,
+      real_inner_smul_left,real_inner_smul_right,gort,mul_zero,add_zero,transverse_sq e x he]
+    dsimp [q]; ring
+  have gaK : inner ℝ (gradient a x) (gradient K x)=0 := by
+    rw [show gradient a x=e from gradient_axis e x,gK]
+    simp [real_inner_smul_right,gort]
+  have gYs : inner ℝ (gradient Y x) (gradient s x)=4*q x*a x*deriv y (q x)*deriv k (q x) := by
+    rw [gY,gs]
+    simp only [inner_add_right,real_inner_smul_left,real_inner_smul_right,
+      transverse_inner e x he,mul_zero,zero_add,real_inner_self_eq_norm_sq,transverse_sq e x he]
+    dsimp [q]; ring
+  have lY : Δ Y x=deriv (deriv y) (q x)*(4*q x)+deriv y (q x)*(2*((Module.finrank ℝ E:ℝ)-1)) := by
+    rw [laplacian_comp hy hq,gn,show Δ q x=2*((Module.finrank ℝ E:ℝ)-1) from laplacian_radiusSq e x he]
+  have lK : Δ K x=deriv (deriv k) (q x)*(4*q x)+deriv k (q x)*(2*((Module.finrank ℝ E:ℝ)-1)) := by
+    rw [laplacian_comp hk hq,gn,show Δ q x=2*((Module.finrank ℝ E:ℝ)-1) from laplacian_radiusSq e x he]
+  have ls : Δ s x=a x*Δ K x := by
+    rw [laplacian_mul ha hK,show Δ a x=0 from laplacian_axis e x,gaK]
+    ring
+  have gH : gradient (fun z=>h (s z)) x=deriv h (s x) • gradient s x :=
+    gradient_comp (hh.differentiableAt (by norm_num)) (hs.differentiableAt (by norm_num))
+  change Δ (fun z=>Y z*h (s z)) x = _
+  have hH : ContDiffAt ℝ 2 (fun z=>h (s z)) x := hh.comp x hs
+  rw [laplacian_mul hY hH,laplacian_comp (f:=s) hh hs,gH,
+    real_inner_smul_right,gYs,gsn,ls,lK,lY]
+  dsimp [Y,K,s,a,q]
+  ring
+end Bernoulli.Cylindrical
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/DominatedVariation.lean

@@ -0,0 +1,70 @@
+import OAI.Analysis.BernoulliCone.HalfspaceGroundstate
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli
+open scoped _root_.Bernoulli
+variable {d : ℕ} {D : Set (Space d)}
+
+lemma dominatedVariation_of_comparison [IsFiniteMeasure (volume.restrict D)]
+    {u v : Space d → ℝ} {G V : Space d → Space d}
+    (hu : H1 D u G) (hv : H10 D v V)
+    (hn : ∀ᵐ x ∂volume.restrict D, 0≤u x)
+    {C : ℝ} (hC : 0<C) (hbound : ∀ᵐ x ∂volume.restrict D, |v x| ≤ C*u x)
+    (hmin : ∀ (w : Space d → ℝ) (W : Space d → Space d),
+      H1 D w W → (∀ᵐ x ∂volume.restrict D, 0≤w x) →
+      H10 D (fun x=>w x-u x) (fun x=>W x-G x) → energy D u G≤energy D w W) :
+    (∫ x in D, inner ℝ (G x) (V x))=0 := by
+  apply linear_coefficient_eq_zero _ (∫ x in D, ‖V x‖^2) (inv_pos.mpr hC)
+  intro t ht
+  have htC : |t| * C<1 := by
+    calc |t| * C < C⁻¹*C := mul_lt_mul_of_pos_right ht hC
+         _ = 1 := inv_mul_cancel₀ hC.ne'
+  have hcontrol : ∀ᵐ x ∂volume.restrict D,
+      0≤u x+t*v x ∧ ((0<u x+t*v x) ↔ 0<u x) := by
+    filter_upwards [hn,hbound] with x hx hbx
+    have hb : |t*v x| ≤ (|t| * C)*u x := by
+      rw [abs_mul,mul_assoc]
+      exact mul_le_mul_of_nonneg_left hbx (abs_nonneg t)
+    by_cases hup : 0<u x
+    · have hp : 0<u x+t*v x := by
+        have := neg_abs_le (t*v x)
+        nlinarith
+      exact ⟨hp.le,iff_of_true hp hup⟩
+    · have hz : u x=0 := le_antisymm (not_lt.mp hup) hx
+      have hvz : v x=0 := abs_eq_zero.mp (le_antisymm (by simpa only [hz,mul_zero] using hbx) (abs_nonneg _))
+      simp only [hz,hvz,mul_zero,add_zero,le_refl,lt_self_iff_false,iff_self,and_self]
+  have hc := hmin (fun x=>u x+t*v x) (fun x=>G x+t • V x)
+    (hu.add (hv.1.const_smul t)) (hcontrol.mono fun _ hx=>hx.1)
+    (by simpa only [add_sub_cancel_left] using hv.const_smul t)
+  rw [energy_affine hu.1 hu.2.1 hv.1.2.1 t (hcontrol.mono fun _ hx=>hx.2)] at hc
+  linarith
+
+lemma GlobalMinimizer.dominatedVariation {u v : Space d → ℝ} {L : ℝ≥0}
+    (hm : GlobalMinimizer u) (hL : LipschitzWith L u)
+    {a : Space d} {R C : ℝ} (hR : 0<R)
+    {V : Space d → Space d} (hv : H10 (ball a R) v V)
+    (hC : 0<C) (hbound : ∀ᵐ x ∂volume.restrict (ball a R), |v x| ≤ C*u x) :
+    (∫ x in ball a R, inner ℝ (gradient u x) (V x))=0 := by
+  let : IsFiniteMeasure (volume.restrict (ball a R)) :=
+    isFiniteMeasure_restrict.mpr measure_ball_lt_top.ne
+  obtain ⟨_,G,hG,hn,hmin⟩ := hm
+  have hu := hG a R hR (subset_univ _)
+  have he := hu.gradient_unique isOpen_ball (LipschitzSobolev.h1_ball hL a R)
+  have hh := dominatedVariation_of_comparison hu hv
+    (ae_restrict_of_ae (by simpa only [Measure.restrict_univ] using hn)) hC hbound
+    (hmin a R hR (subset_univ _))
+  rw [←hh]
+  apply integral_congr_ae
+  filter_upwards [he] with x hx
+  rw [hx]
+end Bernoulli
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/ExteriorCalibration.lean

@@ -0,0 +1,77 @@
+import OAI.Analysis.BernoulliCone.FluxBounds
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+lemma upperFamily_outer_gradient {x:Space 7} {l:ℝ} (hl:0<l)
+    (hq:l^2<Cylindrical.radiusSq axis x) (hp:0<upperFamily l x) :
+    gradient (upperFamily l) x=κ • gradient Zsigned x+
+      (κ*capAmplitude*l^3) • gradient KSup x := by
+  have hqp:0<Cylindrical.radiusSq axis x:=(sq_pos_of_pos hl).trans hq
+  obtain ⟨hx,ha⟩:=radiusSq_pos_data hqp
+  have hdZ:DifferentiableAt ℝ Zsigned x:=(signed_contDiffAt (n:=1) hx ha).differentiableAt (by norm_num)
+  have hdK:DifferentiableAt ℝ KSup x:=(KSup_contDiffAt (n:=1) hx ha).differentiableAt (by norm_num)
+  have he:upperFamily l =ᶠ[𝓝 x] (fun y=>κ*(Zsigned y+capAmplitude*l^3*KSup y)) := by
+    filter_upwards [((Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt).eventually (lt_mem_nhds hq),
+      (upperFamily_continuous l).continuousAt.eventually (lt_mem_nhds hp)] with y hy hpy
+    rw [upperFamily_outer_formula hl hy.le] at hpy ⊢
+    have hh:0<Zsigned y+capAmplitude*l^3*KSup y:=by
+      have hm:=pos_of_mul_pos_right hpy κ_pos.le
+      simpa using hm
+    rw [max_eq_left hh.le]
+  rw [gradient,he.fderiv_eq]
+  change gradient (fun y=>κ*(Zsigned y+capAmplitude*l^3*KSup y)) x=_
+  have hdf:DifferentiableAt ℝ (fun y=>Zsigned y+capAmplitude*l^3*KSup y) x:=
+    hdZ.add (hdK.const_mul (capAmplitude*l^3))
+  rw [gradient_const_mul κ hdf,
+    gradient_add' hdZ (hdK.const_mul (capAmplitude*l^3)),gradient_const_mul (capAmplitude*l^3) hdK,smul_add,smul_smul]
+  congr 2
+  ring
+
+/-- On the actual exterior branch the inverse leaf parameter cancels completely.
+The calibration extends affinely to the lower graph; there is no cube-root
+singularity in the field itself. -/
+theorem upperCalibration_outer_affine {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:(upperParameter p.1 p.2)^2<Cylindrical.radiusSq axis p.1) :
+    upperCalibration p=κ • gradient Zsigned p.1+
+      ((p.2-κ*Zsigned p.1)/KSup p.1) • gradient KSup p.1 := by
+  let l:=upperParameter p.1 p.2
+  obtain ⟨hl,he⟩:=upperParameter_spec hp
+  change 0<l at hl
+  change upperFamily l p.1=p.2 at he
+  have ht:0<p.2:=(U_nonneg _).trans_lt hp
+  have hpos:0<upperFamily l p.1:=by rw [he]; exact ht
+  have hqp:0<Cylindrical.radiusSq axis p.1:=(sq_pos_of_pos hl).trans hq
+  obtain ⟨hx,ha⟩:=radiusSq_pos_data hqp
+  have hK:KSup p.1≠0:=(KSup_pos hx ha).ne'
+  have hqe:Cylindrical.radiusSq axis (l⁻¹ • p.1)≠1:=by
+    rw [Cylindrical.radiusSq_smul]
+    have hh:(l⁻¹)^2*Cylindrical.radiusSq axis p.1>1:=by
+      rw [inv_pow,←div_eq_inv_mul]
+      change 1<Cylindrical.radiusSq axis p.1/l^2
+      exact (lt_div_iff₀ (sq_pos_of_pos hl)).mpr (by simpa only [one_mul] using hq)
+    exact ne_of_gt hh
+  rw [upperCalibration,Foliation.spatialGradient_eq
+    ((upperFamily_contDiffAt_swap hl hpos hqe).differentiableAt (by simp)),
+    upperFamily_outer_gradient hl hq hpos]
+  congr 1
+  have hh:=upperFamily_outer_formula hl hq.le
+  rw [he] at hh
+  have hsg:0<Zsigned p.1+capAmplitude*l^3*KSup p.1:=by
+    have hm:0 < max (Zsigned p.1+capAmplitude*l^3*KSup p.1) 0:=by
+      exact pos_of_mul_pos_right (hh ▸ ht) κ_pos.le
+    simpa using hm
+  rw [max_eq_left hsg.le] at hh
+  apply congrArg (fun a:ℝ=>a • gradient KSup p.1)
+  apply (eq_div_iff hK).mpr
+  nlinarith [hh]
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FluxBounds.lean

@@ -0,0 +1,99 @@
+import OAI.Analysis.BernoulliCone.CalibrationTraces
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+open Axisymmetric
+lemma cap_positive_bounded {x:Space 7} (hq:Cylindrical.radiusSq axis x≤1)
+    (hp:0<smoothCap x) : ‖x‖≤2 := by
+  have hq0:=Cylindrical.radiusSq_nonneg axis x axis_norm
+  obtain ⟨hv,hv1⟩:=CapAlgebra.V_bounds hq0 hq capB_bounds.1 capB_bounds.2
+  have hy:=CapAlgebra.Y_pos hq0 hv capC_pos
+  have hH:0<capH (Cylindrical.axis axis x/CapAlgebra.V (Cylindrical.radiusSq axis x) capB):=by
+    change 0<CapAlgebra.Y _ _ _ * capH (_ * (CapAlgebra.V _ _)⁻¹) at hp
+    rw [←div_eq_mul_inv] at hp
+    exact pos_of_mul_pos_right hp hy.le
+  have ha:|Cylindrical.axis axis x|<3/4:=by
+    have hh:=(capH_pos_iff _).mp hH
+    rw [abs_div,abs_of_pos hv,div_lt_iff₀ hv] at hh
+    nlinarith
+  have hsq:(Cylindrical.axis axis x)^2<(3/4:ℝ)^2:=by
+    rw [←sq_abs]
+    exact (sq_lt_sq₀ (abs_nonneg _) (by norm_num)).mpr ha
+  unfold Cylindrical.radiusSq at hq
+  nlinarith [norm_nonneg x]
+lemma cap_gradient_uniform_bound : ∃C:ℝ,0<C ∧
+    ∀x:Space 7,Cylindrical.radiusSq axis x≤1 → 0<smoothCap x → ‖gradient smoothCap x‖≤C := by
+  let S:Set (Space 7):={x|Cylindrical.radiusSq axis x≤1} ∩ Metric.closedBall 0 2
+  have hs:IsCompact S:=(isCompact_closedBall (0:Space 7) 2).inter_left
+    (isClosed_le (Cylindrical.radiusSq_contDiff axis (n:=1)).continuous continuous_const)
+  have hg:ContinuousOn (gradient smoothCap) S:=by
+    intro x hx
+    have hh:ContDiffAt ℝ ∞ (gradient smoothCap) x:=
+      (toDual ℝ (Space 7)).symm.toContinuousLinearEquiv.contDiff.contDiffAt.comp x
+        ((smoothCap_contDiffAt hx.1).fderiv_right (by simp))
+    exact hh.continuousAt.continuousWithinAt
+  obtain ⟨C,hC⟩:=hs.exists_bound_of_continuousOn hg
+  refine ⟨|C|+1,by positivity,?_⟩
+  intro x hq hp
+  have hx:x∈S:=⟨hq,by simpa using cap_positive_bounded hq hp⟩
+  exact (hC x hx).trans (by linarith [le_abs_self C])
+lemma polarGradient_norm_bound {x:Space 7} (hx:x≠0) (a b:ℝ) :
+    ‖polarGradient axis x a b‖≤|a|+|b| := by
+  have hh:=norm_sq_polarGradient axis_norm hx a b
+  have hab:0≤|a| * |b|:=mul_nonneg (abs_nonneg _) (abs_nonneg _)
+  have hb:0≤(inner ℝ x axis/‖x‖)^2*b^2:=mul_nonneg (sq_nonneg _) (sq_nonneg _)
+  nlinarith [sq_abs a,sq_abs b,norm_nonneg (polarGradient axis x a b),abs_nonneg a,abs_nonneg b]
+lemma outer_gradient_uniform_bound : ∃C:ℝ,0<C ∧
+    ∀x:Space 7,1≤Cylindrical.radiusSq axis x → 0<outerSigned x → ‖gradient outerSigned x‖≤C := by
+  let R:ℝ→ℝ:=fun t=>|f t|+|fp t|+capAmplitude*(2*|gSup t|+|gSup1 t|)
+  have hR:ContinuousOn R (Icc (-3/5:ℝ) (3/5)):=by
+    intro t ht
+    have ht1:t∈Ioo (-1:ℝ) 1:=⟨by linarith [ht.1],by linarith [ht.2]⟩
+    have ht2:|t|<1:=abs_lt.mpr ht1
+    exact (((hasDerivAt_f ht1).continuousAt.abs.add (hasDerivAt_fp ht1).continuousAt.abs).add
+      (continuousAt_const.mul (((hasDerivAt_gSup ht2).continuousAt.abs.const_mul 2).add
+        (hasDerivAt_gSup1 ht2).continuousAt.abs))).continuousWithinAt
+  obtain ⟨C,hC⟩:=isCompact_Icc.exists_bound_of_continuousOn hR
+  refine ⟨|C|+1,by positivity,?_⟩
+  intro x hq hp
+  obtain ⟨hx,ha⟩:=radiusSq_pos_data (show 0<Cylindrical.radiusSq axis x by linarith)
+  have hat:|angle x|≤3/5:=outer_nonnegative_angle hq hp.le
+  have hn:1≤‖x‖:=by
+    unfold Cylindrical.radiusSq at hq
+    nlinarith [norm_nonneg x,sq_nonneg (Cylindrical.axis axis x)]
+  have hn0:0<‖x‖:=by linarith
+  have hfac:0≤‖x‖^(-2:ℝ)/‖x‖ ∧ ‖x‖^(-2:ℝ)/‖x‖≤1:=by
+    rw [Real.rpow_neg (norm_nonneg x),Real.rpow_two]
+    constructor
+    · positivity
+    · apply (div_le_one hn0).mpr
+      exact (inv_le_one_of_one_le₀ (by nlinarith : 1≤‖x‖^2)).trans hn
+  have hc:0≤capAmplitude*(‖x‖^(-2:ℝ)/‖x‖):=mul_nonneg capAmplitude_pos.le hfac.1
+  have hc1:capAmplitude*(‖x‖^(-2:ℝ)/‖x‖)≤capAmplitude:=by nlinarith [capAmplitude_pos]
+  have hm:‖gradient outerSigned x‖≤R (angle x):=by
+    rw [outerSigned_gradient hx ha]
+    calc
+      _≤‖polarGradient axis x (f (angle x)) (fp (angle x))‖+
+          ‖(capAmplitude*(‖x‖^(-2:ℝ)/‖x‖)) • polarGradient axis x (-2*gSup (angle x)) (gSup1 (angle x))‖ := norm_add_le _ _
+      _≤(|f (angle x)|+|fp (angle x)|)+
+          capAmplitude*(2*|gSup (angle x)|+|gSup1 (angle x)|) := by
+        rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg hc]
+        apply add_le_add (polarGradient_norm_bound hx _ _)
+        have hh:=polarGradient_norm_bound hx (-2*gSup (angle x)) (gSup1 (angle x))
+        norm_num only [abs_mul,abs_neg,abs_of_pos (by norm_num : 0<(2:ℝ))] at hh
+        exact (mul_le_mul_of_nonneg_left hh hc).trans
+          (mul_le_mul_of_nonneg_right hc1 (show 0≤2*|gSup (angle x)|+|gSup1 (angle x)| by positivity))
+      _=R (angle x):=rfl
+  have hbound:‖R (angle x)‖≤C:=hC _ (by simpa only [neg_div,Set.mem_Icc] using abs_le.mp hat)
+  exact hm.trans ((le_abs_self _).trans (hbound.trans (by linarith [le_abs_self C])))
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FluxBulk.lean

@@ -0,0 +1,61 @@
+import OAI.Analysis.BernoulliCone.FoliationBulkGerm
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+open Foliation
+lemma normalized_radius_eq_one_iff {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:0<Cylindrical.radiusSq axis p.1) :
+    Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)=1 ↔ seamHeight p.1=p.2 := by
+  let l:=upperParameter p.1 p.2
+  let r:=Real.sqrt (Cylindrical.radiusSq axis p.1)
+  have hl:0<l:=(upperParameter_spec hp).1
+  have hr:0<r:=Real.sqrt_pos.mpr hq
+  have hr2:r^2=Cylindrical.radiusSq axis p.1:=Real.sq_sqrt hq.le
+  have hrl:Cylindrical.radiusSq axis (l⁻¹ • p.1)=1 ↔ l=r:=by
+    rw [Cylindrical.radiusSq_smul,inv_pow,←div_eq_inv_mul,div_eq_one_iff_eq (pow_ne_zero 2 hl.ne'),←hr2]
+    exact (sq_eq_sq₀ hr.le hl.le).trans eq_comm
+  rw [hrl]
+  constructor
+  · intro he
+    have hh:upperFamily r p.1=p.2:=by simpa only [←he] using (upperParameter_spec hp).2
+    rw [upperFamily_at_seam hq] at hh
+    have ht:0<p.2:=(U_nonneg _).trans_lt hp
+    have hs:0<seamHeight p.1:=by
+      by_contra hn
+      rw [max_eq_right (le_of_not_gt hn)] at hh
+      linarith
+    rwa [max_eq_left hs.le] at hh
+  · intro he
+    exact upperParameter_unique hp hr (by rw [upperFamily_at_seam hq,he,max_eq_left ((U_nonneg _).trans hp.le)])
+
+lemma upperFlux_bulk {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:Cylindrical.radiusSq axis ((upperParameter p.1 p.2)⁻¹ • p.1)≠1) :
+    bulkExpression upperFlux p≤0 := by
+  rw [bulkExpression_congr (upperFlux_eventually_eq hp hq)]
+  exact upperCalibration_bulk hp hq
+
+lemma upperFlux_bulk_off_seam {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:0<Cylindrical.radiusSq axis p.1) (hs:seamHeight p.1≠p.2) :
+    bulkExpression upperFlux p≤0 :=
+  upperFlux_bulk hp (fun h=>hs ((normalized_radius_eq_one_iff hp hq).mp h))
+
+lemma exteriorFlux_eventually_eq {p:Space 7×ℝ} (hp:U p.1<p.2)
+    (hq:0<Cylindrical.radiusSq axis p.1) (hs:p.2<seamHeight p.1) :
+    exteriorFlux =ᶠ[𝓝 p] upperFlux := by
+  have hqn:∀ᶠ z:Space 7×ℝ in 𝓝 p,0<Cylindrical.radiusSq axis z.1:=
+    ((Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt.comp continuous_fst.continuousAt).eventually (lt_mem_nhds hq)
+  have hsn:∀ᶠ z:Space 7×ℝ in 𝓝 p,z.2<seamHeight z.1:=
+    continuous_snd.continuousAt.eventually_lt ((seamHeight_contDiffAt hq).continuousAt.comp continuous_fst.continuousAt) hs
+  filter_upwards [above_U_isOpen.mem_nhds hp,hqn,hsn] with z hz hzq hzs
+  exact (upperFlux_eq_exterior hz hzq hzs).symm
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FluxSeam.lean

@@ -0,0 +1,87 @@
+import OAI.Analysis.BernoulliCone.FluxBulk
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.DeSilvaJerison
+lemma outerSigned_dilation_formula {x:Space 7} {l:ℝ} (hl:0<l)
+    (hq:0<Cylindrical.radiusSq axis x) :
+    κ*l*outerSigned (l⁻¹ • x)=κ*(Zsigned x+capAmplitude*l^3*KSup x) := by
+  rw [outerSigned,Zsigned_smul x (inv_pos.mpr hl),KSup_smul hq (inv_pos.mpr hl)]
+  norm_num only [zpow_neg,zpow_ofNat,inv_inv]
+  field_simp
+
+lemma outerSigned_dilation_gradient {x:Space 7} {l:ℝ} (hl:0<l)
+    (hq:0<Cylindrical.radiusSq axis x) :
+    κ • gradient outerSigned (l⁻¹ • x)=κ • gradient Zsigned x+
+      (κ*capAmplitude*l^3) • gradient KSup x := by
+  obtain ⟨hx,ha⟩:=radiusSq_pos_data hq
+  have hqy:0<Cylindrical.radiusSq axis (l⁻¹ • x):=by rw [Cylindrical.radiusSq_smul]; positivity
+  obtain ⟨hyn,hya⟩:=radiusSq_pos_data hqy
+  have hdz:DifferentiableAt ℝ Zsigned x:=(signed_contDiffAt (n:=1) hx ha).differentiableAt (by norm_num)
+  have hdk:DifferentiableAt ℝ KSup x:=(KSup_contDiffAt (n:=1) hx ha).differentiableAt (by norm_num)
+  have he:(fun y=>κ*l*outerSigned (l⁻¹ • y)) =ᶠ[𝓝 x]
+      (fun y=>κ*(Zsigned y+capAmplitude*l^3*KSup y)):=by
+    filter_upwards [((Cylindrical.radiusSq_contDiff axis (n:=1)).continuous.continuousAt).eventually (lt_mem_nhds hq)] with y hy
+    exact outerSigned_dilation_formula hl hy
+  rw [←gradient_dilation hl.ne' ((outerSigned_contDiffAt (n:=1) hyn hya).differentiableAt (by simp)),gradient,he.fderiv_eq]
+  change gradient (fun y=>κ*(Zsigned y+capAmplitude*l^3*KSup y)) x=_
+  have hdf:DifferentiableAt ℝ (fun y=>Zsigned y+capAmplitude*l^3*KSup y) x:=
+    hdz.add (hdk.const_mul (capAmplitude*l^3))
+  rw [gradient_const_mul κ hdf,gradient_add' hdz (hdk.const_mul (capAmplitude*l^3)),
+    gradient_const_mul (capAmplitude*l^3) hdk,smul_add,smul_smul]
+  congr 2
+  ring
+
+lemma seamHeight_signed_dilation {x:Space 7} (hq:0<Cylindrical.radiusSq axis x) :
+    seamHeight x=κ*Real.sqrt (Cylindrical.radiusSq axis x)*
+      outerSigned ((Real.sqrt (Cylindrical.radiusSq axis x))⁻¹ • x) := by
+  rw [outerSigned_at_seam (normalized_radius_seam hq),seamHeight_formula,Cylindrical.axis_smul,div_eq_mul_inv,mul_comm (Cylindrical.axis axis x)]
+
+lemma exteriorFlux_at_seam {x:Space 7} (hq:0<Cylindrical.radiusSq axis x) :
+    exteriorFlux (x,seamHeight x)=
+      κ • gradient outerSigned ((Real.sqrt (Cylindrical.radiusSq axis x))⁻¹ • x) := by
+  let l:=Real.sqrt (Cylindrical.radiusSq axis x)
+  have hl:0<l:=Real.sqrt_pos.mpr hq
+  obtain ⟨hx,ha⟩:=radiusSq_pos_data hq
+  have he:seamHeight x=κ*(Zsigned x+capAmplitude*l^3*KSup x):=by
+    rw [seamHeight_signed_dilation hq]
+    exact outerSigned_dilation_formula hl hq
+  rw [outerSigned_dilation_gradient hl hq]
+  unfold exteriorFlux
+  dsimp only
+  rw [he]
+  congr 1
+  congr 1
+  apply (div_eq_iff (KSup_pos hx ha).ne').mpr
+  ring
+
+lemma upperParameter_at_seam {x:Space 7} (hq:0<Cylindrical.radiusSq axis x)
+    (hp:U x<seamHeight x) : upperParameter x (seamHeight x)=Real.sqrt (Cylindrical.radiusSq axis x) := by
+  exact (upperParameter_unique hp (Real.sqrt_pos.mpr hq)
+    ((upperFamily_at_seam hq).trans (max_eq_left ((U_nonneg x).trans hp.le))))
+
+lemma upperFlux_at_seam {x:Space 7} (hq:0<Cylindrical.radiusSq axis x)
+    (hp:U x<seamHeight x) : upperFlux (x,seamHeight x)=
+      κ • gradient smoothCap ((Real.sqrt (Cylindrical.radiusSq axis x))⁻¹ • x) := by
+  rw [upperFlux,ite_eq_left hp,upperParameter_at_seam hq hp,
+    ite_eq_left (normalized_radius_seam hq).le]
+
+theorem upperFlux_seam_jump {x:Space 7} (hq:0<Cylindrical.radiusSq axis x)
+    (hp:U x<seamHeight x) :
+    ‖upperFlux (x,seamHeight x)‖^2-‖exteriorFlux (x,seamHeight x)‖^2-
+      2*inner ℝ (upperFlux (x,seamHeight x)-exteriorFlux (x,seamHeight x)) (gradient seamHeight x)≤0 := by
+  rw [upperFlux_at_seam hq hp,exteriorFlux_at_seam hq,gradient_seamHeight hq]
+  apply upperCalibration_seam (normalized_radius_seam hq)
+  have hh:0<seamHeight x:=(U_nonneg x).trans_lt hp
+  rw [seamHeight_signed_dilation hq,←upper_seam_agreement (normalized_radius_seam hq)] at hh
+  exact pos_of_mul_pos_right hh (mul_nonneg κ_pos.le (Real.sqrt_nonneg _))
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FoliationBulkGerm.lean

@@ -0,0 +1,29 @@
+import OAI.Analysis.BernoulliCone.PrimitiveLocal
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology
+namespace Bernoulli.Foliation
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+def bulkExpression (A:E×ℝ→E) (p:E×ℝ):ℝ:=
+  divergence (fun x=>A (x,p.2)) p.1+inner ℝ (A p) (deriv (fun t=>A (p.1,t)) p.2)
+lemma bulkExpression_congr {A B:E×ℝ→E} {p:E×ℝ} (he:A =ᶠ[𝓝 p] B) :
+    bulkExpression A p=bulkExpression B p := by
+  have hx:(fun x=>A (x,p.2)) =ᶠ[𝓝 p.1] (fun x=>B (x,p.2)):=
+    he.comp_tendsto (continuousAt_id.prodMk continuousAt_const)
+  have ht:(fun t=>A (p.1,t)) =ᶠ[𝓝 p.2] (fun t=>B (p.1,t)):=
+    he.comp_tendsto (continuousAt_const.prodMk continuousAt_id)
+  unfold bulkExpression divergence
+  rw [hx.fderiv_eq,he.self_of_nhds,ht.deriv_eq]
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FoliationDifferential.lean

@@ -0,0 +1,168 @@
+import OAI.Analysis.BernoulliCone.UpperSmoothLeaves
+
+namespace OAI
+
+universe uE uG
+
+section
+noncomputable section
+open Set Filter InnerProductSpace
+open scoped Topology ContDiff Laplacian
+namespace Bernoulli.Foliation
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+
+/-- Spatial gradient of a smooth one-parameter family, as a joint field. -/
+def spatialGradient (F:E×ℝ→ℝ) (p:E×ℝ) : E :=
+  (toDual ℝ E).symm (fderiv ℝ F p ∘L ContinuousLinearMap.inl ℝ E ℝ)
+
+def divergence (V:E→E) (x:E) : ℝ :=
+  ∑ i, inner ℝ (stdOrthonormalBasis ℝ E i) (fderiv ℝ V x (stdOrthonormalBasis ℝ E i))
+
+lemma inner_spatialGradient (F:E×ℝ→ℝ) (p:E×ℝ) (v:E) :
+    inner ℝ (spatialGradient F p) v = fderiv ℝ F p (v,0) := by
+  rw [spatialGradient,←toDual_apply_apply (𝕜:=ℝ),LinearIsometryEquiv.apply_symm_apply]
+  rfl
+
+omit [FiniteDimensional ℝ E] in
+lemma linear_prod_decomposition {G : Type uG} [NormedAddCommGroup G] [NormedSpace ℝ G]
+    (L:E×ℝ→L[ℝ] G) (v:E) (s:ℝ) : L (v,s)=L (v,0)+s • L (0,1) := by
+  calc
+    _ = L ((v,0)+s • ((0:E),(1:ℝ))) := by congr 1; ext <;> simp
+    _ = _ := by rw [map_add,map_smul]
+
+omit [FiniteDimensional ℝ E] in
+lemma sliceLeft_hasFDerivAt {G : Type uG} [NormedAddCommGroup G] [NormedSpace ℝ G]
+    {F:E×ℝ→G} {p:E×ℝ} (hF:DifferentiableAt ℝ F p) :
+    HasFDerivAt (fun x:E=>F (x,p.2)) (fderiv ℝ F p ∘L ContinuousLinearMap.inl ℝ E ℝ) p.1 := by
+  rcases p with ⟨x,t⟩
+  have hi:HasFDerivAt (fun y:E=>(y,t)) (ContinuousLinearMap.inl ℝ E ℝ) x := by
+    simpa only [ContinuousLinearMap.inl,id_eq] using (hasFDerivAt_id (𝕜:=ℝ) x).prodMk (hasFDerivAt_const t x)
+  exact hF.hasFDerivAt.comp x hi
+
+lemma spatialGradient_eq {F:E×ℝ→ℝ} {p:E×ℝ} (hF:DifferentiableAt ℝ F p) :
+    spatialGradient F p=gradient (fun x:E=>F (x,p.2)) p.1 := by
+  apply ext_inner_right ℝ
+  intro v
+  rw [inner_spatialGradient,inner_gradient_left]
+  have hd := sliceLeft_hasFDerivAt hF
+  rw [hd.fderiv]
+  simp
+
+lemma spatialGradient_contDiffAt {F:E×ℝ→ℝ} {p:E×ℝ} (hF:ContDiffAt ℝ ∞ F p) :
+    ContDiffAt ℝ ∞ (spatialGradient F) p := by
+  have hpart : ContDiffAt ℝ ∞ (fun q:E×ℝ=>fderiv ℝ F q ∘L ContinuousLinearMap.inl ℝ E ℝ) p :=
+    (hF.fderiv_right (by simp)).clm_comp contDiffAt_const
+  exact (toDual ℝ E).symm.toContinuousLinearEquiv.contDiff.contDiffAt.comp p hpart
+
+lemma parameter_directional {F:E×ℝ→ℝ} {L:E×ℝ→ℝ} {p:E×ℝ}
+    (hF:DifferentiableAt ℝ F (p.1,L p)) (hL:DifferentiableAt ℝ L p)
+    (he:∀ᶠ z in 𝓝 p,F (z.1,L z)=z.2)
+    (hρ:fderiv ℝ F (p.1,L p) (0,1)≠0) (v:E) (s:ℝ) :
+    fderiv ℝ L p (v,s)=(s-inner ℝ (spatialGradient F (p.1,L p)) v)/
+      fderiv ℝ F (p.1,L p) (0,1) := by
+  have hd := hF.hasFDerivAt.comp p ((hasFDerivAt_fst (p:=p)).prodMk hL.hasFDerivAt)
+  have hh := congrArg (fun T:E×ℝ→L[ℝ] ℝ=>T (v,s))
+    ((hd.congr_of_eventuallyEq (he.mono (fun _ h=>h.symm))).unique (hasFDerivAt_snd (p:=p)))
+  simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.prod_apply,
+    ] at hh
+  rw [linear_prod_decomposition,smul_eq_mul,←inner_spatialGradient] at hh
+  change inner ℝ (spatialGradient F (p.1,L p)) v +
+    fderiv ℝ L p (v,s) * fderiv ℝ F (p.1,L p) (0,1) = s at hh
+  apply (eq_div_iff hρ).mpr
+  linarith
+
+lemma divergence_gradient {f:E→ℝ} {x:E} (hf:ContDiffAt ℝ ∞ f x) :
+    divergence (gradient f) x=Δ f x := by
+  have hg:ContDiffAt ℝ ∞ (gradient f) x :=
+    (toDual ℝ E).symm.toContinuousLinearEquiv.contDiff.contDiffAt.comp x (hf.fderiv_right (by simp))
+  rw [divergence,laplacian_eq_iteratedFDeriv_stdOrthonormalBasis]
+  apply Finset.sum_congr rfl
+  intro i _
+  let v:=stdOrthonormalBasis ℝ E i
+  have he:(fun y=>inner ℝ (gradient f y) v)=(fun y=>fderiv ℝ f y v) := by
+    ext y
+    exact inner_gradient_left
+  have hh := congrArg (fun T:E→L[ℝ] ℝ=>T v) (congrArg (fun a:E→ℝ=>fderiv ℝ a x) he)
+  have hdir: DifferentiableAt ℝ (fderiv ℝ f) x :=
+    (hf.fderiv_right (m:=∞) (by simp)).differentiableAt (by simp)
+  rw [((hg.differentiableAt (by simp)).hasFDerivAt.inner ℝ (hasFDerivAt_const v x)).fderiv,
+    fderiv_clm_apply hdir (differentiableAt_const v)] at hh
+  simp only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.prod_apply,
+    zero_apply,add_apply,ContinuousLinearMap.flip_apply,
+    fderiv_const_apply,map_zero,zero_add] at hh
+  simp only [fderivInnerCLM_apply,inner_zero_right,zero_add] at hh
+  rw [real_inner_comm] at hh
+  rw [iteratedFDeriv_two_apply]
+  simpa only [Fin.isValue, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_fin_one] using hh
+
+/-- Cancellation of the parameter derivatives in the extended calibration.
+This is the differential identity for an actual foliation, not an assumed PDE. -/
+lemma foliation_divergence {F:E×ℝ→ℝ} {L:E×ℝ→ℝ} {p:E×ℝ}
+    (hF:ContDiffAt ℝ ∞ F (p.1,L p)) (hL:ContDiffAt ℝ ∞ L p)
+    (he:∀ᶠ z in 𝓝 p,F (z.1,L z)=z.2)
+    (hρ:fderiv ℝ F (p.1,L p) (0,1)≠0) :
+    let A:E×ℝ→E:=fun z=>spatialGradient F (z.1,L z)
+    divergence (fun x=>A (x,p.2)) p.1+
+      inner ℝ (A p) (deriv (fun t=>A (p.1,t)) p.2)=
+      Δ (fun x:E=>F (x,L p)) p.1 := by
+  dsimp only
+  let q:E×ℝ:=(p.1,L p)
+  let B:=spatialGradient F
+  let A:E×ℝ→E:=fun z=>B (z.1,L z)
+  let T:=fderiv ℝ B q (0,1)
+  let ρ:=fderiv ℝ F q (0,1)
+  have hBd:DifferentiableAt ℝ B q:=(spatialGradient_contDiffAt hF).differentiableAt (by simp)
+  have hLd:DifferentiableAt ℝ L p:=hL.differentiableAt (by simp)
+  have hFd:DifferentiableAt ℝ F q:=hF.differentiableAt (by simp)
+  have hmap:HasFDerivAt (fun z:E×ℝ=>(z.1,L z))
+      ((ContinuousLinearMap.fst ℝ E ℝ).prod (fderiv ℝ L p)) p :=
+    hasFDerivAt_fst.prodMk hLd.hasFDerivAt
+  have hAd:HasFDerivAt A (fderiv ℝ B q ∘L
+      ((ContinuousLinearMap.fst ℝ E ℝ).prod (fderiv ℝ L p))) p :=
+    by simpa only [A,Function.comp_def,q] using hBd.hasFDerivAt.comp p hmap
+  have hd (v:E) (s:ℝ) : fderiv ℝ A p (v,s)=fderiv ℝ B q (v,0)+
+      ((s-inner ℝ (B q) v)/ρ) • T := by
+    rw [hAd.fderiv]
+    change fderiv ℝ B q (v,fderiv ℝ L p (v,s)) = _
+    rw [linear_prod_decomposition,parameter_directional hFd hLd he hρ]
+  have hx (v:E) : fderiv ℝ (fun x:E=>A (x,p.2)) p.1 v=fderiv ℝ A p (v,0) := by
+    rw [(sliceLeft_hasFDerivAt hAd.differentiableAt).fderiv]
+    simp
+  have ht : deriv (fun t:ℝ=>A (p.1,t)) p.2=ρ⁻¹ • T := by
+    have hh:=hAd.comp_hasDerivAt p.2 ((hasDerivAt_const p.2 p.1).prodMk (hasDerivAt_id p.2))
+    change HasDerivAt (fun t:ℝ=>A (p.1,t)) _ p.2 at hh
+    rw [←hAd.fderiv] at hh
+    rw [hh.deriv]
+    rw [hd]
+    simp only [inner_zero_right,sub_zero,one_div]
+    rw [show ((0:E),(0:ℝ))=(0:E×ℝ) from rfl,map_zero,zero_add]
+  have hspatial : divergence (fun x:E=>B (x,L p)) p.1=Δ (fun x:E=>F (x,L p)) p.1 := by
+    have heq:(fun x:E=>B (x,L p)) =ᶠ[𝓝 p.1] gradient (fun x:E=>F (x,L p)) := by
+      have hn:Tendsto (fun x:E=>(x,L p)) (𝓝 p.1) (𝓝 q):=continuousAt_id.prodMk continuousAt_const
+      have hF1:ContDiffAt ℝ 1 F q:=hF.of_le (by simp)
+      filter_upwards [hn.eventually (hF1.eventually (by simp))] with x hx
+      exact spatialGradient_eq (hx.differentiableAt (by simp))
+    have hfs:ContDiffAt ℝ ∞ (fun x:E=>F (x,L p)) p.1 :=
+      hF.comp p.1 (contDiffAt_id.prodMk contDiffAt_const)
+    rw [divergence,heq.fderiv_eq]
+    exact divergence_gradient hfs
+  have hbase (v:E):fderiv ℝ (fun x:E=>B (x,L p)) p.1 v=fderiv ℝ B q (v,0) := by
+    rw [(sliceLeft_hasFDerivAt hBd).fderiv]
+    simp
+  change divergence (fun x=>A (x,p.2)) p.1+inner ℝ (B q) (deriv (fun t=>A (p.1,t)) p.2)=_
+  rw [ht,←hspatial,divergence,divergence]
+  simp_rw [hx,hbase,hd,inner_add_right,real_inner_smul_right,zero_sub,neg_div]
+  rw [Finset.sum_add_distrib]
+  have hec:(∑ i, -(inner ℝ (B q) (stdOrthonormalBasis ℝ E i)/ρ)*
+      inner ℝ (stdOrthonormalBasis ℝ E i) T) = - (inner ℝ (B q) T/ρ) := by
+    simp only [neg_mul,Finset.sum_neg_distrib,div_mul_eq_mul_div,←Finset.sum_div]
+    rw [(stdOrthonormalBasis ℝ E).sum_inner_mul_inner]
+  rw [hec]
+  ring
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FoliationGraph.lean

@@ -0,0 +1,131 @@
+import OAI.Analysis.BernoulliCone.JointIntervalIntegral
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open MeasureTheory Set Filter InnerProductSpace
+open scoped Topology ContDiff
+namespace Bernoulli.Foliation
+open ParametricIntegral
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [FiniteDimensional ℝ E]
+lemma divergence_graph_primitive {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) :
+    divergence (fun y:E=>heightPrimitive A (y,u y)) x=
+      (∫s in (0:ℝ)..u x,divergence (fun y:E=>A (y,s)) x)+
+        inner ℝ (A (x,u x)) (gradient u x) := by
+  let e:=stdOrthonormalBasis ℝ E
+  have hc:Continuous (fun s:ℝ=>fderiv ℝ A (x,s)):=
+    (hA.continuous_fderiv (by norm_num)).comp (continuous_const.prodMk continuous_id)
+  have hci (i):Continuous (fun s:ℝ=>inner ℝ (e i) (fderiv ℝ A (x,s) (e i,0))):=
+    continuous_const.inner (hc.clm_apply continuous_const)
+  have hi (s:ℝ) (v:E):fderiv ℝ (fun y:E=>A (y,s)) x v=fderiv ℝ A (x,s) (v,0):=by
+    rw [(sliceLeft_hasFDerivAt ((hA.differentiable (by norm_num)) (x,s))).fderiv]
+    simp
+  have he (v:E):inner ℝ v (∫s in (0:ℝ)..u x,fderiv ℝ A (x,s) (v,0))=
+      ∫s in (0:ℝ)..u x,inner ℝ v (fderiv ℝ A (x,s) (v,0)) :=
+    ((innerSL ℝ v).intervalIntegral_comp_comm
+      ((hc.clm_apply continuous_const).intervalIntegrable 0 (u x))).symm
+  rw [divergence]
+  simp_rw [graph_fderiv hA hu,inner_add_right,real_inner_smul_right,he]
+  rw [Finset.sum_add_distrib]
+  congr 1
+  · rw [←intervalIntegral.integral_finsetSum (fun i _=>(hci i).intervalIntegrable 0 (u x))]
+    apply intervalIntegral.integral_congr
+    intro s _
+    simp only [divergence,hi]
+    rfl
+  · simp_rw [←inner_gradient_left]
+    rw [(stdOrthonormalBasis ℝ E).sum_inner_mul_inner]
+    exact real_inner_comm _ _
+lemma continuous_spatial_divergence {A:E×ℝ→E} (hA:ContDiff ℝ 1 A) (x:E) :
+    Continuous (fun s:ℝ=>divergence (fun y:E=>A (y,s)) x) := by
+  have hc:Continuous (fun s:ℝ=>fderiv ℝ A (x,s)):=
+    (hA.continuous_fderiv (by norm_num)).comp (continuous_const.prodMk continuous_id)
+  have hi (s:ℝ) (v:E):fderiv ℝ (fun y:E=>A (y,s)) x v=fderiv ℝ A (x,s) (v,0):=by
+    rw [(sliceLeft_hasFDerivAt ((hA.differentiable (by norm_num)) (x,s))).fderiv]
+    simp
+  simp only [divergence,hi]
+  exact continuous_finsetSum _ (fun i _=>continuous_const.inner (hc.clm_apply continuous_const))
+
+/-- Integrating the nonlinear bulk inequality gives exactly the flux difference.
+This is FTC and parameter differentiation, not a postulated graph comparison. -/
+lemma integrated_bulk {A:E×ℝ→E} (hA:ContDiff ℝ 1 A) (x:E) {a b:ℝ} (hab:a≤b)
+    (hbulk:∀s∈Icc a b,divergence (fun y:E=>A (y,s)) x+
+      inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)≤0) :
+    2*(∫s in a..b,divergence (fun y:E=>A (y,s)) x)≤‖A (x,a)‖^2-‖A (x,b)‖^2 := by
+  have hAC:ContDiff ℝ 1 (fun s:ℝ=>A (x,s)):=hA.comp (contDiff_const.prodMk contDiff_id)
+  have hDC:Continuous (deriv (fun t:ℝ=>A (x,t))) := hAC.continuous_deriv (by norm_num)
+  have hAD(s:ℝ):HasDerivAt (fun t:ℝ=>A (x,t)) (deriv (fun t:ℝ=>A (x,t)) s) s:=
+    (hAC.differentiable (by norm_num) s).hasDerivAt
+  have hN(s:ℝ):HasDerivAt (fun t:ℝ=>‖A (x,t)‖^2)
+      (2*inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)) s:=by
+    simpa only [real_inner_self_eq_norm_sq,real_inner_comm (deriv (fun t:ℝ=>A (x,t)) s),two_mul] using
+      (hAD s).inner ℝ (hAD s)
+  have hc:Continuous (fun s:ℝ=>2*inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)):=
+    continuous_const.mul (hAC.continuous.inner hDC)
+  have hFTC:(∫s in a..b,2*inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s))=
+      ‖A (x,b)‖^2-‖A (x,a)‖^2:=
+    intervalIntegral.integral_eq_sub_of_hasDerivAt (fun s _=>hN s) (hc.intervalIntegrable a b)
+  have hi:IntervalIntegrable (fun s:ℝ=>2*divergence (fun y:E=>A (y,s)) x) volume a b:=
+    (continuous_const.mul (continuous_spatial_divergence hA x)).intervalIntegrable a b
+  have hle:(∫s in a..b,2*divergence (fun y:E=>A (y,s)) x+
+      2*inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s))≤0 := by
+    have hh:=intervalIntegral.integral_mono_on hab (hi.add (hc.intervalIntegrable a b))
+      (intervalIntegrable_const (c:=(0:ℝ))) (fun s hs=>by linarith [hbulk s hs])
+    simpa using hh
+  rw [intervalIntegral.integral_add hi (hc.intervalIntegrable a b),hFTC,
+    intervalIntegral.integral_const_mul] at hle
+  linarith
+lemma divergence_smul_sub {f g:E→E} {x:E}
+    (hf:DifferentiableAt ℝ f x) (hg:DifferentiableAt ℝ g x) (c:ℝ) :
+    divergence (fun y=>c • (f y-g y)) x=c*(divergence f x-divergence g x) := by
+  have hh:HasFDerivAt (fun y=>c • (f y-g y)) (c • (fderiv ℝ f x-fderiv ℝ g x)) x:=
+    (hf.hasFDerivAt.sub hg.hasFDerivAt).const_smul c
+  rw [divergence,hh.fderiv]
+  simp only [smul_apply,sub_apply,
+    real_inner_smul_right,inner_sub_right,Finset.mul_sum,Finset.sum_sub_distrib,divergence,mul_sub]
+
+def graphPotential (A:E×ℝ→E) (u v:E→ℝ) (x:E) : E :=
+  (2:ℝ) • (heightPrimitive A (x,v x)-heightPrimitive A (x,u x))
+lemma graph_potential_identity {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u v:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) (hv:DifferentiableAt ℝ v x) :
+    divergence (graphPotential A u v) x=
+      2*(∫s in u x..v x,divergence (fun y:E=>A (y,s)) x)+
+        2*inner ℝ (A (x,v x)) (gradient v x)-2*inner ℝ (A (x,u x)) (gradient u x) := by
+  have hd(w:E→ℝ)(hw:DifferentiableAt ℝ w x):
+      DifferentiableAt ℝ (fun y:E=>heightPrimitive A (y,w y)) x:=
+    DifferentiableAt.comp (f:=fun y:E=>(y,w y)) (g:=heightPrimitive A) x
+      (heightPrimitive_differentiable hA (x,w x)) (differentiableAt_id.prodMk hw)
+  unfold graphPotential
+  rw [divergence_smul_sub (hd v hv) (hd u hu),
+    divergence_graph_primitive hA hv,divergence_graph_primitive hA hu]
+  have hi:=intervalIntegral.integral_interval_sub_left (μ:=volume)
+    ((continuous_spatial_divergence hA x).intervalIntegrable 0 (v x))
+    ((continuous_spatial_divergence hA x).intervalIntegrable 0 (u x))
+  rw [←hi]
+  ring
+
+lemma graph_potential_bulk_bound {A:E×ℝ→E} (hA:ContDiff ℝ 1 A)
+    {u v:E→ℝ} {x:E} (hu:DifferentiableAt ℝ u x) (hv:DifferentiableAt ℝ v x)
+    (huv:u x≤v x)
+    (hbulk:∀s∈Icc (u x) (v x),divergence (fun y:E=>A (y,s)) x+
+      inner ℝ (A (x,s)) (deriv (fun t:ℝ=>A (x,t)) s)≤0) :
+    divergence (graphPotential A u v) x≤‖gradient v x‖^2+
+      ‖A (x,u x)‖^2-2*inner ℝ (A (x,u x)) (gradient u x) := by
+  have hi:=integrated_bulk hA x huv hbulk
+  have hs:0≤‖gradient v x-A (x,v x)‖^2:=sq_nonneg _
+  rw [norm_sub_sq_real] at hs
+  have he:inner ℝ (gradient v x) (A (x,v x))=inner ℝ (A (x,v x)) (gradient v x):=real_inner_comm _ _
+  rw [he] at hs
+  rw [graph_potential_identity hA hu hv]
+  linarith
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/FoliationSeam.lean

@@ -0,0 +1,43 @@
+import OAI.Analysis.BernoulliCone.UpperCalibration
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open scoped RealInnerProductSpace
+namespace Bernoulli.Foliation
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+/-- The extended calibration jump across the graph of a matching seam. -/
+lemma seam_flux_identity (Gp Gm H N:E) (ρp ρm:ℝ)
+    (hp:H=Gp+ρp • N) (hm:H=Gm+ρm • N) :
+    ‖Gp‖^2-‖Gm‖^2-2*inner ℝ (Gp-Gm) H=
+      -(ρp+ρm)*inner ℝ (Gp-Gm) N := by
+  have hh:Gp+Gm-(2:ℝ) • H=-(ρp+ρm) • N := by
+    rw [hp] at hm
+    have hg:Gm=Gp+(ρp-ρm) • N := by
+      calc
+        Gm = (Gm+ρm • N)-ρm • N := by abel
+        _ = _ := by rw [←hm]; module
+    rw [hg,hp]
+    module
+  have hid:inner ℝ (Gp-Gm) (Gp+Gm-(2:ℝ) • H)=
+      ‖Gp‖^2-‖Gm‖^2-2*inner ℝ (Gp-Gm) H := by
+    simp only [inner_sub_right,inner_add_right,inner_sub_left,real_inner_smul_right,
+      real_inner_self_eq_norm_sq]
+    rw [real_inner_comm Gm Gp]
+    ring
+  rw [←hid,hh,real_inner_smul_right]
+lemma seam_flux_nonpos (Gp Gm H N:E) (ρp ρm:ℝ)
+    (hp:H=Gp+ρp • N) (hm:H=Gm+ρm • N)
+    (hρ:0≤ρp+ρm) (hj:0 ≤ inner ℝ (Gp-Gm) N) :
+    ‖Gp‖^2-‖Gm‖^2-2*inner ℝ (Gp-Gm) H≤0 := by
+  rw [seam_flux_identity Gp Gm H N ρp ρm hp hm]
+  exact mul_nonpos_of_nonpos_of_nonneg (neg_nonpos.mpr hρ) hj
+end Bernoulli.Foliation
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/GlobalMinimizer.lean

@@ -0,0 +1,84 @@
+import OAI.Analysis.BernoulliCone.UpperComparison
+
+namespace OAI
+
+section
+noncomputable section
+open Set Filter InnerProductSpace MeasureTheory
+open scoped Topology ContDiff NNReal
+namespace Bernoulli.DeSilvaJerison
+
+/-- The constructed double-cone is a global energy minimizer against the full
+arbitrary Sobolev competitor class. Upper and lower comparisons are joined by
+the exact Sobolev lattice identity, including its contact-level gradients. -/
+theorem U_global_minimizer : GlobalMinimizer U := by
+  refine ⟨isOpen_univ,gradient U,U_h1loc,?_,?_⟩
+  · simpa only [Measure.restrict_univ] using (Eventually.of_forall U_nonneg : ∀ᵐ x:Space 7 ∂volume,0≤U x)
+  intro c r hr hB v V hv hvn htrace
+  let B:=Metric.ball c r
+  let G:=gradient U
+  have hu:H1 B U G:=U_h1loc c r hr (subset_univ _)
+  have hpos:=SobolevCalculus.h10_positivePart Metric.isOpen_ball htrace
+  have hneg:H10 B (fun x=>max (U x-v x) 0)
+      (fun x=>(if 0<U x-v x then (1:ℝ) else 0) • (G x-V x)):=by
+    simpa only [neg_sub] using SobolevCalculus.h10_positivePart Metric.isOpen_ball htrace.neg
+  let p:=fun x=>U x+max (v x-U x) 0
+  let P:=fun x=>G x+(if 0<v x-U x then (1:ℝ) else 0) • (V x-G x)
+  let m:=fun x=>U x-max (U x-v x) 0
+  let M:=fun x=>G x-(if 0<U x-v x then (1:ℝ) else 0) • (G x-V x)
+  have hp:H1 B p P:=hu.add hpos.1
+  have hm:H1 B m M:=hu.sub hneg.1
+  have hpt:H10 B (fun x=>p x-U x) (fun x=>P x-G x):=by
+    apply hpos.congr
+    · exact Eventually.of_forall (fun x=>by dsimp [p]; ring)
+    · exact Eventually.of_forall (fun x=>by dsimp [P]; abel)
+  have hmt:H10 B (fun x=>m x-U x) (fun x=>M x-G x):=by
+    apply hneg.neg.congr
+    · exact Eventually.of_forall (fun x=>by dsimp [m]; ring)
+    · exact Eventually.of_forall (fun x=>by dsimp [M]; abel)
+  have hUp:∀ᵐ x ∂volume.restrict B,U x≤p x:=
+    Eventually.of_forall fun x=>le_add_of_nonneg_right (le_max_right _ _)
+  have hmU:∀ᵐ x ∂volume.restrict B,m x≤U x:=
+    Eventually.of_forall fun x=>sub_le_self _ (le_max_right _ _)
+  have hmn:∀ᵐ x ∂volume.restrict B, 0 ≤ m x:=by
+    filter_upwards [hvn] with x hx
+    change 0≤U x-max (U x-v x) 0
+    exact sub_nonneg.mpr (max_le (by linarith) (U_nonneg x))
+  have hupper:=U_upper_comparison c r hr hp hUp hpt
+  have hlower:=U_lower_comparison c r hr hm hmn hmU hmt
+  let :IsFiniteMeasure (volume.restrict B):=isFiniteMeasure_restrict.mpr measure_ball_lt_top.ne
+  have hI {f:Space 7→ℝ} {F:Space 7→Space 7} (h:H1 B f F):
+      Integrable (fun x=>‖F x‖^2+if 0<f x then (1:ℝ) else 0) (volume.restrict B):=
+    (h.2.1.integrable_norm_pow (by norm_num)).add (integrable_phase h.1.aestronglyMeasurable)
+  have henergy:energy B m M+energy B p P=energy B U G+energy B v V:=by
+    rw [energy,energy,energy,energy,←integral_add (hI hm) (hI hp),←integral_add (hI hu) (hI hv)]
+    apply integral_congr_ae
+    filter_upwards [SobolevCalculus.gradient_zero_on_zero_set Metric.isOpen_ball htrace.1] with x hz
+    rcases lt_trichotomy (v x) (U x) with hlt|he|hgt
+    · have h1:¬0<v x-U x:=by linarith
+      have h2:0<U x-v x:=by linarith
+      have he:m x=v x:=by dsimp [m]; rw [max_eq_left h2.le]; ring
+      simp only [he,p,P,M,ite_eq_right h1,ite_eq_left h2,zero_smul,one_smul,add_zero,
+        sub_sub_cancel,max_eq_right (not_lt.mp h1)]
+      ring
+    · have hVG:V x=G x:=sub_eq_zero.mp (hz (by rw [he,sub_self]))
+      simp only [p,P,m,M,he,hVG,sub_self,lt_self_iff_false,ite_false,zero_smul,
+        max_self,add_zero,sub_zero]
+    · have h1:0<v x-U x:=by linarith
+      have h2:¬0<U x-v x:=by linarith
+      have he:p x=v x:=by dsimp [p]; rw [max_eq_left h1.le]; ring
+      simp only [he,m,M,P,ite_eq_left h1,ite_eq_right h2,zero_smul,one_smul,sub_zero,
+        add_sub_cancel,max_eq_right (not_lt.mp h2)]
+  change energy B U G≤energy B p P at hupper
+  change energy B U G≤energy B m M at hlower
+  linarith
+
+theorem exists_nonflat_dimension_seven :
+    ∃u:Space 7→ℝ,GlobalMinimizer u ∧ Nonzero u ∧ OneHomogeneous u ∧ ¬Flat u :=
+  ⟨U,U_global_minimizer,U_nonzero,U_homogeneous,U_not_flat⟩
+end Bernoulli.DeSilvaJerison
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/GroundState.lean

@@ -0,0 +1,328 @@
+import OAI.Analysis.BernoulliCone.ConePicone
+
+namespace OAI
+
+universe uF
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal Topology ContDiff Laplacian
+namespace Bernoulli
+open scoped _root_.Bernoulli
+variable {d : ℕ} {D : Set (Space d)}
+namespace GroundState
+
+lemma compact_extension_near_test (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hφ : Test D φ) :
+    ∃ F : Space d → ℝ, ContDiff ℝ ∞ F ∧ HasCompactSupport F ∧
+      ∀x∈tsupport φ, F =ᶠ[𝓝 x] Y := by
+  obtain ⟨χ,hχ,hχc,hχD,hχ1,_⟩ := exists_cutoff hφ.2.1 hD hφ.2.2
+  refine ⟨fun x=>χ x*Y x,?_,hχc.mul_right,?_⟩
+  · rw [contDiff_iff_contDiffAt]
+    intro x
+    by_cases hx : x∈tsupport χ
+    · exact hχ.contDiffAt.mul (hY.contDiffAt (hD.mem_nhds (hχD hx)))
+    · apply (contDiffAt_const (c:=(0:ℝ))).congr_of_eventuallyEq
+      filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hx] with y hy
+      simp [hy]
+  · intro x hx
+    filter_upwards [hχ1.filter_mono (nhds_le_nhdsSet hx)] with y hy
+    simp [hy]
+
+lemma compact_green {F φ : Space d → ℝ} (hF : ContDiff ℝ ∞ F)
+    (hc : HasCompactSupport F) (hφ : Test univ φ) :
+    (∫x, inner ℝ (gradient F x) (gradient φ x)) = -(∫x, Δ F x*φ x) := by
+  have hi := (show Test univ F from ⟨hF,hc,subset_univ _⟩).h1.laplacian_ibp hφ
+  simp only [Measure.restrict_univ] at hi
+  have hs := SchwartzMap.integral_mul_laplacian_right_eq_left
+    (hc.toSchwartzMap hF) (hφ.2.1.toSchwartzMap hφ.1) (μ:=volume)
+  simp only [SchwartzMap.laplacian_apply] at hs
+  change (∫x, F x*Δ φ x)=(∫x, Δ F x*φ x) at hs
+  linarith
+
+lemma local_green (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hφ : Test D φ) :
+    (∫x, inner ℝ (gradient Y x) (gradient φ x)) = -(∫x, Δ Y x*φ x) := by
+  obtain ⟨F,hF,hFc,hFY⟩ := compact_extension_near_test hD hY hφ
+  have hi := compact_green hF hFc (show Test univ φ from ⟨hφ.1,hφ.2.1,subset_univ _⟩)
+  convert! hi using 1
+  · apply integral_congr_ae
+    exact ae_of_all _ fun x=>by
+      by_cases hx : x∈tsupport φ
+      · dsimp only
+        simp only [gradient,(hFY x hx).fderiv_eq]
+      · have hz : gradient φ x=0 := by rw [gradient,fderiv_of_notMem_tsupport ℝ hx,map_zero]
+        simp [hz]
+  · congr 1
+    apply integral_congr_ae
+    exact ae_of_all _ fun x=>by
+      by_cases hx : x∈tsupport φ
+      · dsimp only
+        rw [(InnerProductSpace.laplacian_congr_nhds (hFY x hx)).eq_of_nhds]
+      · simp [image_eq_zero_of_notMem_tsupport hx]
+
+lemma local_green_integrable (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hφ : Test D φ) :
+    Integrable (fun x=>inner ℝ (gradient Y x) (gradient φ x)) ∧
+    Integrable (fun x=>Δ Y x*φ x) := by
+  obtain ⟨F,hF,hFc,hFY⟩ := compact_extension_near_test hD hY hφ
+  have hFtest : Test univ F := ⟨hF,hFc,subset_univ _⟩
+  have hφtest : Test univ φ := ⟨hφ.1,hφ.2.1,subset_univ _⟩
+  have hgrad := integrable_inner_of_memLp hFtest.memLp_gradient hφtest.memLp_gradient
+  simp only [Measure.restrict_univ] at hgrad
+  have hLap : Continuous (Δ F) := by
+    let S := hFc.toSchwartzMap hF
+    have he : (Laplacian.laplacian S : Space d → ℝ)=Δ F := funext fun x=>SchwartzMap.laplacian_apply S x
+    exact he ▸ (Laplacian.laplacian S).continuous
+  have hi : Integrable (fun x=>Δ F x*φ x) volume :=
+    (hLap.mul hφ.1.continuous).integrable_of_hasCompactSupport hφ.2.1.mul_left
+  constructor
+  · apply hgrad.congr
+    exact ae_of_all _ fun x=>by
+      by_cases hx : x∈tsupport φ
+      · dsimp only
+        simp only [gradient,(hFY x hx).fderiv_eq]
+      · have hz : gradient φ x=0 := by rw [gradient,fderiv_of_notMem_tsupport ℝ hx,map_zero]
+        simp [hz]
+  · apply hi.congr
+    exact ae_of_all _ fun x=>by
+      by_cases hx : x∈tsupport φ
+      · dsimp only
+        rw [(InnerProductSpace.laplacian_congr_nhds (hFY x hx)).eq_of_nhds]
+      · simp [image_eq_zero_of_notMem_tsupport hx]
+
+open Halfspace
+
+lemma square_ratio_test (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x) (hφ : Test D φ) :
+    Test D (positiveSquareRatio φ Y) := by
+  have hs : tsupport (positiveSquareRatio φ Y)⊆tsupport φ := by
+    apply closure_mono
+    intro x hx
+    by_contra hn
+    have hz : φ x=0 := Function.notMem_support.mp hn
+    change positiveSquareRatio φ Y x ≠ 0 at hx
+    exact hx (by simp [positiveSquareRatio,hz])
+  refine ⟨?_,hφ.2.1.of_isClosed_subset (isClosed_tsupport _) hs,hs.trans hφ.2.2⟩
+  rw [contDiff_iff_contDiffAt]
+  intro x
+  by_cases hx : x∈tsupport φ
+  · have hy := hY.contDiffAt (hD.mem_nhds (hφ.2.2 hx))
+    have hp := hYp x (hφ.2.2 hx)
+    have he : positiveSquareRatio φ Y =ᶠ[𝓝 x] (fun y=>φ y^2/Y y) := by
+      filter_upwards [hy.continuousAt.preimage_mem_nhds (Ioi_mem_nhds hp)] with y hh
+      change 0 < Y y at hh
+      simp only [positiveSquareRatio,ite_eq_left hh]
+    exact ((hφ.1.contDiffAt.pow 2).div hy hp.ne').congr_of_eventuallyEq he
+  · apply (contDiffAt_const (c:=(0:ℝ))).congr_of_eventuallyEq
+    filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hx] with y hy
+    change φ y = 0 at hy
+    simp [positiveSquareRatio,hy]
+
+lemma picone_identity (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x) (hφ : Test D φ) (x : Space d) :
+    ‖gradient φ x-(φ x/Y x) • gradient Y x‖^2 = ‖gradient φ x‖^2-
+      inner ℝ (gradient Y x) (gradient (positiveSquareRatio φ Y) x) := by
+  by_cases hx : x∈D
+  · rw [positiveSquareRatio_gradient
+      ((hY.contDiffAt (hD.mem_nhds hx)).differentiableAt (by simp))
+      (hφ.1.differentiable (by simp) x) (hYp x hx)]
+    rw [norm_sub_sq_real]
+    simp only [inner_sub_right,real_inner_smul_right,real_inner_self_eq_norm_sq,
+      norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,real_inner_comm (gradient φ x) (gradient Y x)]
+    ring
+  · rw [hφ.eq_zero_outside hx,hφ.gradient_eq_zero_outside hx,
+      (square_ratio_test hD hY hYp hφ).gradient_eq_zero_outside hx]
+    simp
+
+/-- Ground-state square completion for arbitrary compact smooth tests in a
+positive superharmonic domain. It is proved by the weak integration-by-parts
+identity, not inserted as an assumption about the explicit barrier. -/
+theorem picone_test (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x)
+    (hLap : ∀x∈D, Δ Y x≤0) (hφ : Test D φ) :
+    (∫x, ‖gradient φ x-(φ x/Y x) • gradient Y x‖^2) ≤
+      (∫x, ‖gradient φ x‖^2) := by
+  have hq := square_ratio_test hD hY hYp hφ
+  have hqi := local_green_integrable hD hY hq
+  have hgr := local_green hD hY hq
+  have hn : (∫x, Δ Y x*positiveSquareRatio φ Y x)≤0 := by
+    apply integral_nonpos
+    intro x
+    by_cases hx : x∈D
+    · exact mul_nonpos_of_nonpos_of_nonneg (hLap x hx) (positiveSquareRatio_nonneg x)
+    · simp [hq.eq_zero_outside hx]
+  have hφtest : Test univ φ := ⟨hφ.1,hφ.2.1,subset_univ _⟩
+  have hi := hφtest.memLp_gradient.integrable_norm_pow (show (2:ℕ)≠0 by simp)
+  simp only [Measure.restrict_univ] at hi
+  simp_rw [picone_identity hD hY hYp hφ]
+  rw [integral_sub hi hqi.1]
+  linarith
+
+lemma drift_test_memLp (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x) (hφ : Test D φ) :
+    MemLp (fun x=>gradient φ x-(φ x/Y x) • gradient Y x) 2 volume := by
+  have hc : Continuous (fun x=>(φ x/Y x) • gradient Y x) := by
+    rw [continuous_iff_continuousAt]
+    intro x
+    by_cases hx : x∈tsupport φ
+    · have hy := hY.contDiffAt (hD.mem_nhds (hφ.2.2 hx))
+      exact (hφ.1.continuous.continuousAt.div hy.continuousAt (hYp x (hφ.2.2 hx)).ne').smul
+        ((InnerProductSpace.toDual ℝ (Space d)).symm.continuous.continuousAt.comp
+          (hy.continuousAt_fderiv (by simp)))
+    · apply (continuousAt_const (y:=(0:Space d))).congr_of_eventuallyEq
+      filter_upwards [notMem_tsupport_iff_eventuallyEq.mp hx] with y hy
+      change φ y=0 at hy
+      simp [hy]
+  have hs : HasCompactSupport (fun x=>(φ x/Y x) • gradient Y x) := by
+    apply hφ.2.1.of_isClosed_subset (isClosed_tsupport _)
+    apply closure_mono
+    intro x hx
+    change (φ x/Y x) • gradient Y x ≠ 0 at hx
+    change φ x ≠ 0
+    intro hz
+    exact hx (by simp [hz])
+  have hφt : Test univ φ := ⟨hφ.1,hφ.2.1,subset_univ _⟩
+  have hg := hφt.memLp_gradient
+  simp only [Measure.restrict_univ] at hg
+  exact hg.sub (hc.memLp_of_hasCompactSupport hs)
+
+lemma integral_norm_sq_eq {F : Type uF} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
+    {μ : Measure (Space d)} {f : Space d → F} (hf : MemLp f 2 μ) :
+    (∫x, ‖f x‖^2 ∂μ)=‖hf.toLp f‖^2 := by
+  rw [← real_inner_self_eq_norm_sq,L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [hf.coeFn_toLp] with x hx
+  rw [hx,real_inner_self_eq_norm_sq]
+
+lemma picone_test_eLpNorm (hD : IsOpen D) {Y φ : Space d → ℝ}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x)
+    (hLap : ∀x∈D, Δ Y x≤0) (hφ : Test D φ) :
+    eLpNorm (fun x=>gradient φ x-(φ x/Y x) • gradient Y x) 2 (volume.restrict D) ≤
+      eLpNorm (gradient φ) 2 (volume.restrict D) := by
+  have hφt : Test univ φ := ⟨hφ.1,hφ.2.1,subset_univ _⟩
+  have hg := hφt.memLp_gradient
+  simp only [Measure.restrict_univ] at hg
+  have hl := drift_test_memLp hD hY hYp hφ
+  have hi := picone_test hD hY hYp hLap hφ
+  rw [integral_norm_sq_eq hl,integral_norm_sq_eq hg] at hi
+  have hn : ‖hl.toLp _‖ ≤ ‖hg.toLp _‖ := (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mp hi
+  have hh : eLpNorm (fun x=>gradient φ x-(φ x/Y x) • gradient Y x) 2 volume ≤
+      eLpNorm (gradient φ) 2 volume := by
+    rw [← Lp.enorm_toLp hl,← Lp.enorm_toLp hg,← ofReal_norm,← ofReal_norm]
+    exact ENNReal.ofReal_le_ofReal hn
+  have he : eLpNorm (gradient φ) 2 (volume.restrict D)=eLpNorm (gradient φ) 2 volume := by
+    rw [← eLpNorm_indicator_eq_eLpNorm_restrict hD.measurableSet]
+    congr 1
+    ext x
+    by_cases hx : x∈D
+    · simp [hx]
+    · simp [hx,hφ.gradient_eq_zero_outside hx]
+  rw [he]
+  exact (eLpNorm_mono_measure _ Measure.restrict_le_self).trans hh
+
+/-- The full H¹₀ ground-state inequality. Fatou's lemma handles the singular
+coefficient at the boundary or cone vertex; no bounded-drift or Hardy hypothesis
+is imposed. -/
+theorem picone_h10_eLpNorm (hD : IsOpen D) {Y w : Space d → ℝ} {G : Space d → Space d}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x)
+    (hLap : ∀x∈D, Δ Y x≤0) (hw : H10 D w G) :
+    MemLp (fun x=>G x-(w x/Y x) • gradient Y x) 2 (volume.restrict D) ∧
+    eLpNorm (fun x=>G x-(w x/Y x) • gradient Y x) 2 (volume.restrict D) ≤
+      eLpNorm G 2 (volume.restrict D) := by
+  obtain ⟨φ,hφ,hφw,hφG⟩ := SobolevCalculus.H10_sequence hw
+  have htψ := tendstoInMeasure_of_tendsto_eLpNorm (by norm_num : (2:ENNReal)≠0)
+    hφw
+  have htG := tendstoInMeasure_of_tendsto_eLpNorm (by norm_num : (2:ENNReal)≠0)
+    hφG
+  obtain ⟨a,ha,haw⟩ := htψ.exists_seq_tendsto_ae
+  obtain ⟨b,hb,hbG⟩ := (htG.comp ha.tendsto_atTop).exists_seq_tendsto_ae
+  let ψ := fun n=>φ (a (b n))
+  have hψ : ∀n, Test D (ψ n) := fun n=>hφ (a (b n))
+  let T := fun n x=>gradient (ψ n) x-(ψ n x/Y x) • gradient Y x
+  let L := fun x=>G x-(w x/Y x) • gradient Y x
+  have hT : ∀n, MemLp (T n) 2 (volume.restrict D) := fun n=>
+    (drift_test_memLp hD hY hYp (hψ n)).mono_measure Measure.restrict_le_self
+  have hTL : ∀ᵐ x ∂volume.restrict D, Tendsto (fun n=>T n x) atTop (𝓝 (L x)) := by
+    filter_upwards [haw,hbG] with x hx hy
+    exact hy.sub (((hx.comp hb.tendsto_atTop).div_const (Y x)).smul tendsto_const_nhds)
+  have hLm := aestronglyMeasurable_of_tendsto_ae _
+    (fun n=>(hT n).aestronglyMeasurable) hTL
+  have hl := Lp.eLpNorm_lim_le_liminf_eLpNorm (p:=2)
+    (fun n=>(hT n).aestronglyMeasurable) L hLm hTL
+  have hGnorm : Tendsto (fun n=>eLpNorm (gradient (ψ n)) 2 (volume.restrict D)) atTop
+      (𝓝 (eLpNorm G 2 (volume.restrict D))) := by
+    have hLp : Tendsto (fun n=>(hφ n).memLp_gradient.toLp (gradient (φ n))) atTop
+        (𝓝 (hw.1.2.1.toLp G)) := by
+      apply tendsto_iff_enorm_sub_tendsto_zero.mpr
+      simpa only [← MemLp.toLp_sub,Lp.enorm_toLp] using hφG
+    have hh := hLp.enorm.comp (ha.tendsto_atTop.comp hb.tendsto_atTop)
+    simpa only [Lp.enorm_toLp,Function.comp_def,ψ] using hh
+  have hbound : eLpNorm L 2 (volume.restrict D) ≤ eLpNorm G 2 (volume.restrict D) := by
+    refine hl.trans ?_
+    rw [← hGnorm.liminf_eq]
+    apply Filter.liminf_le_liminf
+    · exact Eventually.of_forall fun n=>picone_test_eLpNorm hD hY hYp hLap (hψ n)
+    all_goals isBoundedDefault
+  exact ⟨hbound.trans_lt hw.1.2.1,hbound⟩
+
+theorem picone_h10 (hD : IsOpen D) {Y w : Space d → ℝ} {G : Space d → Space d}
+    (hY : ContDiffOn ℝ ∞ Y D) (hYp : ∀x∈D, 0<Y x)
+    (hLap : ∀x∈D, Δ Y x≤0) (hw : H10 D w G) :
+    (∫x in D, ‖G x-(w x/Y x) • gradient Y x‖^2) ≤
+      (∫x in D, ‖G x‖^2) := by
+  obtain ⟨hl,hb⟩ := picone_h10_eLpNorm hD hY hYp hLap hw
+  have ht := ENNReal.toReal_mono hw.1.2.1.ne hb
+  rw [integral_norm_sq_eq hl,integral_norm_sq_eq hw.1.2.1,Lp.norm_toLp,Lp.norm_toLp]
+  exact pow_le_pow_left₀ ENNReal.toReal_nonneg ht 2
+
+lemma orthogonal_h10_of_tests {G : Space d → Space d}
+    (hG : MemLp G 2 (volume.restrict D))
+    (ht : ∀φ, Test D φ → (∫x in D, inner ℝ (G x) (gradient φ x))=0) :
+    ∀v V, H10 D v V → (∫x in D, inner ℝ (G x) (V x))=0 := by
+  intro v V hv
+  obtain ⟨f,hf,_,hfG⟩ := SobolevCalculus.H10_sequence hv
+  have hl : Tendsto (fun n => (hf n).memLp_gradient.toLp (gradient (f n)))
+      atTop (𝓝 (hv.1.2.1.toLp V)) := by
+    apply tendsto_iff_enorm_sub_tendsto_zero.mpr
+    simpa only [← MemLp.toLp_sub,Lp.enorm_toLp] using hfG
+  have hi : Tendsto (fun n => inner ℝ (hG.toLp G)
+      ((hf n).memLp_gradient.toLp (gradient (f n)))) atTop
+      (𝓝 (inner ℝ (hG.toLp G) (hv.1.2.1.toLp V))) := tendsto_const_nhds.inner hl
+  have he n : inner ℝ (hG.toLp G) ((hf n).memLp_gradient.toLp (gradient (f n)))=0 := by
+    rw [L2.inner_def]
+    convert! ht (f n) (hf n) using 1
+    apply integral_congr_ae
+    filter_upwards [hG.coeFn_toLp,(hf n).memLp_gradient.coeFn_toLp] with x hx hy
+    rw [hx,hy]
+  simp only [he] at hi
+  have hz := tendsto_nhds_unique hi tendsto_const_nhds
+  rw [L2.inner_def] at hz
+  convert! hz using 1
+  apply integral_congr_ae
+  filter_upwards [hG.coeFn_toLp,hv.1.2.1.coeFn_toLp] with x hx hy
+  rw [hx,hy]
+
+theorem harmonic_h10 (hD : IsOpen D) {u w : Space d → ℝ} {G : Space d → Space d}
+    (hu : ContDiffOn ℝ ∞ u D) (hLap : ∀x∈D, Δ u x=0)
+    (hG : MemLp (gradient u) 2 (volume.restrict D)) (hw : H10 D w G) :
+    (∫x in D, inner ℝ (gradient u x) (G x))=0 := by
+  apply orthogonal_h10_of_tests hG _ w G hw
+  intro φ hφ
+  rw [setIntegral_eq_integral_of_forall_compl_eq_zero
+    (fun x hx=>by rw [hφ.gradient_eq_zero_outside hx,inner_zero_right])]
+  rw [local_green hD hu hφ]
+  suffices hh : (fun x=>Δ u x*φ x)=(fun _=>0) by rw [hh,integral_zero,neg_zero]
+  ext x
+  by_cases hx:x∈D
+  · simp [hLap x hx]
+  · simp [hφ.eq_zero_outside hx]
+
+end GroundState
+end Bernoulli
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/HalfspaceDensity.lean

@@ -0,0 +1,70 @@
+import OAI.Analysis.BernoulliCone.HalfspacePullback
+
+namespace OAI
+
+universe uE
+
+section
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+namespace Bernoulli.Shape
+variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
+
+def density (u : E → ℝ) (x : E) : ℝ := ‖gradient u x‖^2+if 0 < u x then 1 else 0
+
+def firstTerm (φ : E → ℝ) (e : E) (x : E) : ℝ :=
+  if 0 < inner ℝ e x then fderiv ℝ φ x e else 0
+
+lemma density_nonneg (u : E → ℝ) (x : E) : 0 ≤ density u x := by
+  unfold density
+  split_ifs <;> positivity
+
+lemma gradient_norm_le_lipschitz {φ : E → ℝ} {C : ℝ≥0}
+    (hφ : LipschitzWith C φ) {x : E} (hd : DifferentiableAt ℝ φ x) :
+    ‖gradient φ x‖ ≤ C := by
+  rw [gradient,LinearIsometryEquiv.norm_map]
+  exact hd.hasFDerivAt.le_of_lipschitz hφ
+
+lemma density_pullback_bound {φ : E → ℝ} {C : ℝ≥0} {x : E}
+    (hφ : DifferentiableAt ℝ φ x) (hLip : LipschitzWith C φ)
+    (e : E) (t : ℝ) (h : (1:ℝ)/2 ≤ 1+t*fderiv ℝ φ x e)
+    (g : E ≃ₜ E) (hg : ∀ y, g y=deform φ e t y) (hx : inner ℝ e x ≠ 0) :
+    (1+t*fderiv ℝ φ x e)*density (fun y => positiveLinear e (g.symm y)) (g x) ≤
+      density (positiveLinear e) x + t*(1-‖e‖^2)*firstTerm φ e x +
+        t^2*(2*‖e‖^4*C^2) := by
+  have hpos : 0 < 1+t*fderiv ℝ φ x e := lt_of_lt_of_le (by norm_num) h
+  have hne := hpos.ne'
+  have hv : positiveLinear e (g.symm (g x)) = positiveLinear e x := by rw [g.symm_apply_apply]
+  rcases lt_or_gt_of_ne hx with hx|hx
+  · rw [density,pullback_gradient_neg hφ e t hne g hg hx,hv,density,
+      positiveLinear_gradient_neg e hx,firstTerm]
+    simp only [positiveLinear,max_eq_right hx.le,lt_self_iff_false,ite_false,norm_zero,zero_pow,
+      ne_eq,OfNat.ofNat_ne_zero,not_false_eq_true,zero_add,mul_zero,add_zero,not_lt.mpr hx.le]
+    positivity
+  · have hgNorm := gradient_norm_le_lipschitz hLip hφ
+    have hsq : ‖gradient φ x‖^2 ≤ (C:ℝ)^2 := by nlinarith [norm_nonneg (gradient φ x),C.coe_nonneg]
+    have hnum : 0 ≤ t^2*‖e‖^4 := mul_nonneg (sq_nonneg _) (pow_nonneg (norm_nonneg _) _)
+    have hn : 0 ≤ t^2*‖e‖^4*(C:ℝ)^2 := mul_nonneg hnum (sq_nonneg _)
+    have hr : t^2*‖e‖^4*‖gradient φ x‖^2/(1+t*fderiv ℝ φ x e) ≤
+        t^2*(2*‖e‖^4*C^2) := by
+      apply (div_le_iff₀ hpos).mpr
+      have h1 := mul_le_mul_of_nonneg_left hsq hnum
+      have h2 : t^2*‖e‖^4*(C:ℝ)^2 ≤ (2*(t^2*‖e‖^4*(C:ℝ)^2))*(1+t*fderiv ℝ φ x e) := by
+        nlinarith
+      apply h1.trans
+      calc
+        _ ≤ (2*(t^2*‖e‖^4*(C:ℝ)^2))*(1+t*fderiv ℝ φ x e) := h2
+        _ = _ := by ring
+    have hc := pullback_density_algebra e (gradient φ x) t (by simpa only [inner_gradient_right,conj_trivial] using hne)
+    simp only [inner_gradient_right,conj_trivial] at hc
+    rw [density,pullback_gradient_pos hφ e t hne g hg hx,hv,density,
+      positiveLinear_gradient_pos e hx,firstTerm,ite_eq_left hx]
+    simp only [positiveLinear,max_eq_left hx.le,ite_eq_left hx]
+    linarith
+end Bernoulli.Shape
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/HalfspaceDifferential.lean

@@ -0,0 +1,93 @@
+import OAI.Analysis.BernoulliCone.HomogeneousCalculus
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli.Halfspace
+open HarmonicKernel
+variable {d : ℕ}
+
+lemma squareQuotient_hasFDerivAt {u : Space d → ℝ} {e x : Space d}
+    (hu : DifferentiableAt ℝ u x) (ht : 0 < inner ℝ x e) :
+    HasFDerivAt (squareQuotient u e)
+      ((inner ℝ x e)⁻¹ • ((2*u x) • fderiv ℝ u x)-
+        (u x^2/(inner ℝ x e)^2) • innerSL ℝ e) x := by
+  have hi : HasFDerivAt (fun y : Space d => inner ℝ y e) (innerSL ℝ e) x := by
+    convert! (innerSL ℝ e).hasFDerivAt (x:=x) using 1
+    funext y
+    exact (real_inner_comm y e).symm
+  have hh := (hu.hasFDerivAt.pow 2).mul ((hasDerivAt_inv ht.ne').comp_hasFDerivAt x hi)
+  have he : (squareQuotient u e) =ᶠ[𝓝 x] (fun y=>u y^2/inner ℝ y e) := by
+    filter_upwards [(continuous_id.inner continuous_const).continuousAt.preimage_mem_nhds
+      (Ioi_mem_nhds ht)] with y hy
+    change 0 < inner ℝ y e at hy
+    simp only [squareQuotient,ite_eq_left hy]
+  simp only [Function.comp_apply] at hh
+  convert! hh.congr_of_eventuallyEq he using 1
+  ext v
+  simp only [sub_apply,smul_apply,smul_eq_mul,innerSL_apply_apply,add_apply,
+    Nat.cast_ofNat,pow_one,Nat.reduceSub,nsmul_eq_mul]
+  field_simp
+  ring
+
+lemma potential_gradient (x : Space d) :
+    gradient (potential : Space d → ℝ) x = -rawKernel x • x := by
+  apply ext_inner_right ℝ
+  intro e
+  rw [inner_gradient_left,real_inner_smul_left]
+  have hh := radial_directional (contDiff_profile.differentiable (by simp)) x e
+  rw [show (fun y : Space d=>profile (‖y‖^2))=potential from rfl] at hh
+  rw [hh]
+  simp only [rawKernel,kernelProfile]
+  ring
+
+lemma potential_nonneg (x : Space d) : 0 ≤ potential x := expNegInvGlue.nonneg _
+lemma potential_pos {x : Space d} (hx : x∈ball (0:Space d) 1) : 0 < potential x := by
+  apply expNegInvGlue.pos_of_pos
+  rw [mem_ball_zero_iff] at hx
+  nlinarith [norm_nonneg x]
+
+lemma weightedQuotient_directional {u : Space d → ℝ} {e x : Space d}
+    (hu : DifferentiableAt ℝ u x) (ht : 0 < inner ℝ x e) (he : ‖e‖=1) :
+    inner ℝ (gradient (fun y=>potential y*squareQuotient u e y) x) e =
+      -rawKernel x*u x^2 + potential x*(
+        2*(u x/inner ℝ x e)*inner ℝ (gradient u x) e-(u x/inner ℝ x e)^2) := by
+  have hφ := (contDiff_potential.differentiable (by simp) x).hasFDerivAt
+  have hq := squareQuotient_hasFDerivAt hu ht
+  have hp := hφ.mul hq
+  change HasFDerivAt (fun y=>potential y*squareQuotient u e y) _ x at hp
+  rw [inner_gradient_left,hp.fderiv]
+  simp only [add_apply,smul_apply,smul_eq_mul,sub_apply,innerSL_apply_apply]
+  simp only [← inner_gradient_left,potential_gradient,real_inner_smul_left,
+    real_inner_self_eq_norm_sq,he]
+  simp only [squareQuotient,ite_eq_left ht,one_pow,mul_one]
+  field_simp
+  ring
+
+lemma radial_outer_identity {u : Space d → ℝ} {L : ℝ≥0}
+    (hm : GlobalMinimizer u) (hL : LipschitzWith L u)
+    (hom : ∀r:ℝ, 0<r → ∀x, u (r•x)=r*u x) :
+    (∫ x in ball (0:Space d) 2, potential x*‖gradient u x‖^2-rawKernel x*u x^2)=0 := by
+  have hφ : Test (ball (0:Space d) 2) potential := by
+    have he : (potential : Space d → ℝ)=scaledPotential 1 0 := by
+      funext x; simp [potential,scaledPotential]
+    rw [he]
+    exact scaledPotential_test (by norm_num) 0 (closedBall_subset_ball (by norm_num))
+  have hh := hm.outerVariation hL (by norm_num : 0 < (2:ℝ)) hφ
+  rw [← hh]
+  apply integral_congr_ae
+  filter_upwards [ae_restrict_of_ae hL.ae_differentiableAt] with x hx
+  have he := ConeCalculus.euler_identity hx hom
+  rw [← inner_gradient_left] at he
+  simp only [inner_add_right,real_inner_smul_right,real_inner_self_eq_norm_sq,potential_gradient]
+  rw [he]
+  ring
+end Bernoulli.Halfspace
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/HalfspaceEnergy.lean

@@ -0,0 +1,108 @@
+import OAI.Analysis.BernoulliCone.RankOneDeterminant
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli.Shape
+variable {d : ℕ}
+
+lemma inner_ne_zero_ae {e : Space d} (he : e ≠ 0) :
+    ∀ᵐ x ∂volume, inner ℝ e x ≠ 0 := by
+  let a := innerSL ℝ e
+  have ha : a ≠ 0 := by
+    intro hh
+    have hx : inner ℝ e e=0 := by
+      have h := congrArg (fun f : Space d →L[ℝ] ℝ => f e) hh
+      simpa [a] using h
+    exact he ((inner_self_eq_zero).mp hx)
+  have hker : volume (LinearMap.ker a.toLinearMap : Set (Space d))=0 := by
+    apply Measure.addHaar_submodule
+    rw [Ne,LinearMap.ker_eq_top]
+    intro hh
+    exact ha (ContinuousLinearMap.coe_injective hh)
+  rw [ae_iff]
+  change volume {x | ¬ inner ℝ e x ≠ 0}=0
+  change volume {x | inner ℝ e x=0}=0 at hker
+  simpa only [not_not] using hker
+
+lemma density_integrable_ball {u : Space d → ℝ} {C : ℝ≥0} (hu : LipschitzWith C u)
+    (a : Space d) (R : ℝ) : IntegrableOn (density u) (ball a R) := by
+  let : IsFiniteMeasure (volume.restrict (ball a R)) :=
+    isFiniteMeasure_restrict.mpr (measure_ball_lt_top.ne)
+  have hh := LipschitzSobolev.h1_ball hu a R
+  exact (hh.2.1.integrable_norm_pow (by norm_num)).add (integrable_phase hh.1.aestronglyMeasurable)
+
+lemma firstTerm_integrable_ball {φ : Space d → ℝ} (hφ : ContDiff ℝ ∞ φ)
+    (e a : Space d) (R : ℝ) : IntegrableOn (firstTerm φ e) (ball a R) := by
+  have hc : Continuous (fun x => fderiv ℝ φ x e) := (hφ.continuous_fderiv (by simp)).clm_apply continuous_const
+  have hi : IntegrableOn (fun x => fderiv ℝ φ x e) (ball a R) volume :=
+    (hc.continuousOn.integrableOn_compact (isCompact_closedBall a R)).mono_set ball_subset_closedBall
+  have hpos : MeasurableSet {x : Space d | 0 < inner ℝ e x} :=
+    (isOpen_lt continuous_const (innerSL ℝ e).continuous).measurableSet
+  exact hi.indicator hpos
+
+lemma energy_pullback_upper {φ : Space d → ℝ} {C : ℝ≥0}
+    (hφ : ContDiff ℝ ∞ φ) (hLip : LipschitzWith C φ)
+    {e : Space d} (he : e ≠ 0) (t : ℝ)
+    (hdet : ∀ x, (1:ℝ)/2 ≤ 1+t*fderiv ℝ φ x e)
+    (g : Space d ≃ₜ Space d) (hg : ∀ y, g y=deform φ e t y)
+    (a : Space d) (R : ℝ) (hfix : ∀ x ∉ ball a R, φ x=0) :
+    energy (ball a R) (fun y => positiveLinear e (g.symm y))
+        (gradient (fun y => positiveLinear e (g.symm y))) ≤
+      energy (ball a R) (positiveLinear e) (gradient (positiveLinear e)) +
+        t*(1-‖e‖^2)*(∫ x in ball a R, firstTerm φ e x) +
+        t^2*(2*‖e‖^4*C^2)*(volume (ball a R)).toReal := by
+  let : IsFiniteMeasure (volume.restrict (ball a R)) :=
+    isFiniteMeasure_restrict.mpr (measure_ball_lt_top.ne)
+  let v := fun y => positiveLinear e (g.symm y)
+  have him : g '' ball a R=ball a R := image_eq_of_fixed_compl g _ (by
+    intro x hx
+    rw [hg]
+    simp [deform,hfix x hx])
+  have hchange := integral_image_eq_integral_abs_det_fderiv_smul (s:=ball a R) volume measurableSet_ball
+    (f:=g) (f':=fun x => rankOneMap (fderiv ℝ φ x) e t)
+    (fun x _ => (show HasFDerivAt g (rankOneMap (fderiv ℝ φ x) e t) x from by
+      rw [show (g : Space d → Space d)=deform φ e t from funext hg]
+      exact hasFDerivAt_deform ((hφ.differentiable (by simp)) x).hasFDerivAt e t).hasFDerivWithinAt) (g.injective.injOn) (density v)
+  rw [him] at hchange
+  have hdetpos (x : Space d) : 0 ≤ 1+t*fderiv ℝ φ x e := le_trans (by norm_num) (hdet x)
+  simp_rw [rankOneMap_det,abs_of_nonneg (hdetpos _),smul_eq_mul] at hchange
+  change energy (ball a R) v (gradient v) = _ at hchange
+  rw [hchange]
+  have hi : Integrable (fun x => density (positiveLinear e) x+t*(1-‖e‖^2)*firstTerm φ e x+
+      t^2*(2*‖e‖^4*C^2)) (volume.restrict (ball a R)) := by
+    convert ((density_integrable_ball (positiveLinear_lipschitz e) a R).add
+    ((firstTerm_integrable_ball hφ e a R).const_mul (t*(1-‖e‖^2)))).add
+      (integrable_const (t^2*(2*‖e‖^4*C^2))) using 1; rfl
+  have hm := integral_mono_of_nonneg
+    (μ:=volume.restrict (ball a R))
+    (f:=fun x => (1+t*fderiv ℝ φ x e)*density v (g x))
+    (g:=fun x => density (positiveLinear e) x+t*(1-‖e‖^2)*firstTerm φ e x+
+      t^2*(2*‖e‖^4*C^2))
+    (Eventually.of_forall (fun x => mul_nonneg (hdetpos x) (density_nonneg v (g x)))) hi
+    (by
+      filter_upwards [ae_restrict_of_ae (inner_ne_zero_ae he)] with x hx
+      exact density_pullback_bound ((hφ.differentiable (by simp)) x) hLip e t (hdet x) g hg hx)
+  have hiE := density_integrable_ball (positiveLinear_lipschitz e) a R
+  have hiF := (firstTerm_integrable_ball hφ e a R).const_mul (t*(1-‖e‖^2))
+  have hsum : (∫ x in ball a R, density (positiveLinear e) x+t*(1-‖e‖^2)*firstTerm φ e x+
+      t^2*(2*‖e‖^4*C^2)) =
+      energy (ball a R) (positiveLinear e) (gradient (positiveLinear e)) +
+        t*(1-‖e‖^2)*(∫ x in ball a R, firstTerm φ e x) +
+        t^2*(2*‖e‖^4*C^2)*(volume (ball a R)).toReal := by
+    have hadd := integral_add (hiE.add hiF) (integrable_const (t^2*(2*‖e‖^4*C^2)))
+    have hadd2 := integral_add hiE hiF
+    simp only [Pi.add_apply] at hadd
+    rw [hadd2,integral_const_mul,integral_const] at hadd
+    convert hadd using 1; first | rfl | (simp only [Measure.restrict_apply_univ,Measure.real,smul_eq_mul]; dsimp [energy,density]; ring)
+  rw [hsum] at hm
+  exact hm
+end Bernoulli.Shape
+
+end
+end
+
+end OAI

lean/OAI/Analysis/BernoulliCone/HalfspaceGroundstate.lean

@@ -0,0 +1,88 @@
+import OAI.Analysis.BernoulliCone.CompactGradient
+
+namespace OAI
+
+section
+noncomputable section
+open MeasureTheory Set Filter Metric
+open scoped Topology NNReal ENNReal ContDiff
+namespace Bernoulli.Halfspace
+open HarmonicKernel
+variable {d : ℕ}
+
+lemma radial_potential_test : Test (ball (0:Space d) 2) potential := by
+  have he : (potential : Space d → ℝ)=scaledPotential 1 0 := by
+    funext x; simp [potential,scaledPotential]
+  rw [he]
+  exact scaledPotential_test (by norm_num) 0 (closedBall_subset_ball (by norm_num))
+
+lemma radial_outer_integrable {u : Space d → ℝ} {L : ℝ≥0} (hL : LipschitzWith L u) :
+    IntegrableOn (fun x=> potential x*‖gradient u x‖^2-rawKernel x*u x^2) (ball (0:Space d) 2) := by
+  have hu := LipschitzSobolev.h1_ball hL 0 2
+  have hi := (memLp_two_iff_integrable_sq_norm hu.2.1.aestronglyMeasurable).mp hu.2.1
+  obtain ⟨C,hC⟩ := (radial_potential_test (d:=d)).2.1.exists_bound_of_continuous contDiff_potential.continuous
+  have hi' := hi.bdd_mul contDiff_potential.continuous.aestronglyMeasurable (Eventually.of_forall hC)
+  have hq : Integrable (fun x=>rawKernel x*u x^2) volume :=
+    (contDiff_rawKernel.continuous.mul (hL.continuous.pow 2)).integrable_of_hasCompactSupport rawKernel_compact.mul_right
+  exact hi'.sub hq.integrableOn
+
+/-- Ground-state equality for a true homogeneous minimizing cone supported in
+one closed halfspace. This uses a Lipschitz perspective competitor, not a
+regularity assumption or a boundary trace quotient. -/
+theorem gradient_parallel_of_halfspace_support {u : Space d → ℝ} {L : ℝ≥0}
+    (hm : GlobalMinimizer u) (hL : LipschitzWith L u)
+    (hom : ∀r:ℝ, 0<r → ∀x, u (r•x)=r*u x)
+    {e : Space d} (he : ‖e‖=1) (hz : ∀x, inner ℝ x e ≤ 0 → u x=0) :
+    ∀ᵐ x ∂volume.restrict (ball (0:Space d) 1),
+      gradient u x=(u x/inner ℝ x e) • e := by
+  let B := ball (0:Space d) 2
+  let μ := volume.restrict B
+  let : IsFiniteMeasure μ := isFiniteMeasure_restrict.mpr measure_ball_lt_top.ne
+  let q := fun x=>potential x*squareQuotient u e x
+  have hφ : Test B potential := radial_potential_test
+  obtain ⟨K,hφL⟩ := ContDiff.lipschitzWith_of_hasCompactSupport hφ.2.1 hφ.1 (by simp)
+  obtain ⟨C,hq'⟩ := lipschitz_mul_compact (squareQuotient_lipschitz hL he hz) hφL hφ.2.1
+  have hq : LipschitzWith C q := by
+    simpa only [q,mul_comm] using hq'
+  have hc : HasCompactSupport q := hφ.2.1.mul_right
+  have hs : tsupport q ⊆ B := tsupport_mul_subset_left.trans hφ.2.2
+  have hq0 := setIntegral_gradient_compact hq hc hs e
+  have hu0 := SobolevCalculus.gradient_zero_on_zero_set isOpen_ball (LipschitzSobolev.h1_ball hL 0 2)
+  have hqz := SobolevCalculus.gradient_zero_on_zero_set isOpen_ball (LipschitzSobolev.h1_ball hq 0 2)
+  let F := fun x=>potential x*‖gradient u x‖^2-rawKernel x*u x^2
+  let R := fun x=>potential x*‖gradient u x-(u x/inner ℝ x e) • e‖^2
+  have hR : R =ᵐ[μ] (fun x=>F x-inner ℝ (gradient q x) e) := by
+    filter_upwards [ae_restrict_of_ae hL.ae_differentiableAt,hu0,hqz] with x hx hux hqx
+    by_cases ht : 0 < inner ℝ x e
+    · dsimp [R,F,q]
+      rw [weightedQuotient_directional hx ht he]
+      rw [← real_inner_self_eq_norm_sq]
+      simp only [inner_sub_left,inner_sub_right,real_inner_smul_left,real_inner_smul_right,
+        real_inner_self_eq_norm_sq, norm_smul, Real.norm_eq_abs, he, mul_one, sq_abs, real_inner_comm e (gradient u x)]
+      ring
+    · have hu : u x=0 := hz x (not_lt.mp ht)
+      have hqv : q x=0 := by simp [q,squareQuotient,ht]
+      simp only [R,F,hu,hux hu,hqx hqv,zero_div,zero_smul,sub_self,norm_zero,zero_pow (by norm_num : 2≠0),
+        mul_zero,inner_zero_left]
+  have hFi : Integrable F μ := radial_outer_integrable hL
+  have hQi : Integrable (fun x=>inner ℝ (gradient q x) e) μ :=
+    (memLp_inner_const (LipschitzSobolev.h1_ball hq 0 2).2.1 e).integrable (by norm_num)
+  have hRi : Integrable R μ := (hFi.sub hQi).congr hR.symm
+  have hRint : (∫ x, R x ∂μ)=0 := by
+    rw [integral_congr_ae hR,integral_sub hFi hQi]
+    change (∫ x in B, F x)-(∫ x in B, inner ℝ (gradient q x) e)=0
+    rw [radial_outer_identity hm hL hom,hq0,sub_self]
+  have haz : R =ᵐ[μ] 0 := (integral_eq_zero_iff_of_nonneg_ae
+    (Eventually.of_forall (fun x=>mul_nonneg (potential_nonneg x) (sq_nonneg _))) hRi).mp hRint
+  have hle : volume.restrict (ball (0:Space d) 1) ≤ μ :=
+    Measure.restrict_mono (ball_subset_ball (by norm_num)) le_rfl
+  filter_upwards [ae_mono hle haz,ae_restrict_mem measurableSet_ball] with x hx hxb
+  have hsq : ‖gradient u x-(u x/inner ℝ x e) • e‖^2=0 :=
+    (mul_eq_zero.mp hx).resolve_left (potential_pos hxb).ne'
+  exact sub_eq_zero.mp (norm_eq_zero.mp (sq_eq_zero_iff.mp hsq))
+end Bernoulli.Halfspace
+
+end
+end
+
+end OAI