lean/OAI/Analysis/BackwardIntertwiners/ConvexEnvelope.lean

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