import Mathlib

namespace OAI

/-! Local L2 restriction and bounded varying multipliers. -/

namespace BFSSLocalL2
noncomputable section
open MeasureTheory Set Filter Topology
variable {E F : Type*} [MeasurableSpace E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]
variable (μ : Measure E) (s : Set E)

def restrictLinear : Lp F 2 μ →ₗ[ℝ] Lp F 2 (μ.restrict s) where
  toFun f := ((Lp.memLp f).restrict s).toLp f
  map_add' f g := by
    apply Lp.ext
    filter_upwards [MemLp.coeFn_toLp ((Lp.memLp (f+g)).restrict s),
      MemLp.coeFn_toLp ((Lp.memLp f).restrict s), MemLp.coeFn_toLp ((Lp.memLp g).restrict s),
      Lp.coeFn_add (((Lp.memLp f).restrict s).toLp f) (((Lp.memLp g).restrict s).toLp g),
      ae_restrict_of_ae (Lp.coeFn_add f g)] with x hfg hf hg ha hb
    simp only [Pi.add_apply,hf,hg] at ha hb
    exact hfg.trans (hb.trans ha.symm)
  map_smul' c f := by
    apply Lp.ext
    filter_upwards [MemLp.coeFn_toLp ((Lp.memLp (c • f)).restrict s),
      MemLp.coeFn_toLp ((Lp.memLp f).restrict s),
      Lp.coeFn_smul c (((Lp.memLp f).restrict s).toLp f),
      ae_restrict_of_ae (Lp.coeFn_smul c f)] with x hcf hf ha hb
    simp only [Pi.smul_apply,hf] at ha hb
    exact hcf.trans (hb.trans ha.symm)

lemma restrictLinear_norm_le (f : Lp F 2 μ) : ‖restrictLinear μ s f‖ ≤ ‖f‖ := by
  change ‖((Lp.memLp f).restrict s).toLp f‖ ≤ ‖f‖
  rw [Lp.norm_toLp,Lp.norm_def]
  exact ENNReal.toReal_mono (Lp.eLpNorm_ne_top f) (eLpNorm_mono_measure _ (Measure.restrict_le_self))

def restrict : Lp F 2 μ →L[ℝ] Lp F 2 (μ.restrict s) :=
  (restrictLinear μ s).mkContinuous 1 (fun f => by simpa using restrictLinear_norm_le μ s f)

lemma restrict_ae (f : Lp F 2 μ) : (restrict μ s f : E → F) =ᵐ[μ.restrict s] f :=
  MemLp.coeFn_toLp ((Lp.memLp f).restrict s)

variable {μ s}
omit [NormedSpace ℝ F] in
lemma norm_le_of_ae_norm_le (f g : Lp F 2 μ) (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) : ‖f‖ ≤ ‖g‖ := by
  rw [Lp.norm_def,Lp.norm_def]
  exact ENNReal.toReal_mono (Lp.eLpNorm_ne_top g)
    (eLpNorm_mono_ae (Lp.memLp f).aestronglyMeasurable h)

lemma norm_le_mul_of_ae_norm_le (f g : Lp F 2 μ) (c : ℝ) (hc : 0 ≤ c)
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ c*‖g x‖) : ‖f‖ ≤ c*‖g‖ := by
  rw [←abs_of_nonneg hc,←Real.norm_eq_abs,←norm_smul]
  apply norm_le_of_ae_norm_le
  filter_upwards [h,Lp.coeFn_smul c g] with x hx hg
  rw [hg,Pi.smul_apply,norm_smul,Real.norm_eq_abs,abs_of_nonneg hc]
  exact hx
end
end BFSSLocalL2
namespace BFSSLocalL2
noncomputable section
open MeasureTheory Set Filter Topology
variable {E F : Type*} [MeasurableSpace E]
  [NormedAddCommGroup F] [InnerProductSpace ℝ F] {μ : Measure E}

lemma boundedMul_mem (w : E → ℝ) (hw : AEStronglyMeasurable w μ)
    (B : ℝ) (hB : ∀ᵐ x ∂μ, |w x| ≤ B) (f : Lp F 2 μ) :
    MemLp (fun x => w x • f x) 2 μ := by
  apply (Lp.memLp f).of_le_mul (hw.smul (Lp.memLp f).aestronglyMeasurable)
  filter_upwards [hB] with x hx
  change ‖w x • f x‖ ≤ B*‖f x‖
  rw [norm_smul,Real.norm_eq_abs]
  exact mul_le_mul_of_nonneg_right hx (norm_nonneg _)

def boundedMul (w : E → ℝ) (hw : AEStronglyMeasurable w μ)
    (B : ℝ) (hB : ∀ᵐ x ∂μ, |w x| ≤ B) (f : Lp F 2 μ) : Lp F 2 μ :=
  (boundedMul_mem w hw B hB f).toLp (fun x => w x • f x)

lemma boundedMul_ae (w : E → ℝ) (hw : AEStronglyMeasurable w μ)
    (B : ℝ) (hB : ∀ᵐ x ∂μ, |w x| ≤ B) (f : Lp F 2 μ) :
    (boundedMul w hw B hB f : E → F) =ᵐ[μ] fun x => w x • f x :=
  MemLp.coeFn_toLp _

attribute [local irreducible] boundedMul

lemma boundedMul_dist_le (w : E → ℝ) (hw : AEStronglyMeasurable w μ)
    (B : ℝ) (hB0 : 0 ≤ B) (hB : ∀ᵐ x ∂μ, |w x| ≤ B) (f g : Lp F 2 μ) :
    dist (boundedMul w hw B hB f) (boundedMul w hw B hB g) ≤ B*dist f g := by
  simp only [dist_eq_norm]
  apply norm_le_mul_of_ae_norm_le _ (f-g) B hB0
  filter_upwards [boundedMul_ae w hw B hB f, boundedMul_ae w hw B hB g,
    Lp.coeFn_sub (boundedMul w hw B hB f) (boundedMul w hw B hB g),
    Lp.coeFn_sub f g,hB] with x hf hg hs hfg hx
  rw [hs,Pi.sub_apply,hf,hg,←smul_sub,hfg,Pi.sub_apply,norm_smul,Real.norm_eq_abs]
  exact mul_le_mul_of_nonneg_right hx (norm_nonneg _)

lemma lp_norm_sq (f : Lp F 2 μ) : ‖f‖^2 = ∫ x, ‖f x‖^2 ∂μ := by
  rw [←real_inner_self_eq_norm_sq,L2.inner_def]
  simp only [real_inner_self_eq_norm_sq]

theorem boundedMul_fixed_tendsto (w : ℕ → E → ℝ) (hw : ∀ n, AEStronglyMeasurable (w n) μ)
    (B : ℝ) (_hB0 : 0 ≤ B) (hB : ∀ n, ∀ᵐ x ∂μ, |w n x| ≤ B)
    (hlim : ∀ᵐ x ∂μ, Tendsto (fun n => w n x) atTop (𝓝 1)) (u : Lp F 2 μ) :
    Tendsto (fun n => boundedMul (w n) (hw n) B (hB n) u) atTop (𝓝 u) := by
  have ht : Tendsto (fun n => ∫ x, ‖(w n x-1) • u x‖^2 ∂μ) atTop (𝓝 0) := by
    have hu := (Lp.memLp u).integrable_norm_pow (by decide : 2 ≠ 0)
    have hd := tendsto_integral_of_dominated_convergence
      (F := fun n x => ‖(w n x-1) • u x‖^2) (f := fun _ => (0 : ℝ))
      (fun x => (B+1)^2*‖u x‖^2)
      (fun n => (((hw n).sub aestronglyMeasurable_const).smul
        (Lp.memLp u).aestronglyMeasurable).norm.pow 2)
      (hu.const_mul ((B+1)^2)) ?_ ?_
    · simpa only [integral_zero] using hd
    · intro n
      filter_upwards [hB n] with x hx
      rw [Real.norm_eq_abs,abs_of_nonneg (sq_nonneg _),norm_smul,Real.norm_eq_abs,mul_pow]
      have hh : |w n x-1| ≤ B+1 := by
        calc
          |w n x-1| ≤ |w n x|+1 := by simpa only [abs_one] using abs_sub (w n x) 1
          _ ≤ B+1 := by linarith
      exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (abs_nonneg _) hh 2) (sq_nonneg _)
    · filter_upwards [hlim] with x hx
      have hh := ((hx.sub (tendsto_const_nhds (x := (1 : ℝ)))).smul
        (tendsto_const_nhds (x := u x))).norm.pow 2
      simpa only [sub_self,zero_smul,norm_zero,zero_pow (by decide : 2 ≠ 0)] using hh
  have he (n : ℕ) : dist (boundedMul (w n) (hw n) B (hB n) u) u ^2 =
      ∫ x, ‖(w n x-1) • u x‖^2 ∂μ := by
    rw [dist_eq_norm,lp_norm_sq]
    apply integral_congr_ae
    filter_upwards [boundedMul_ae (w n) (hw n) B (hB n) u,
      Lp.coeFn_sub (boundedMul (w n) (hw n) B (hB n) u) u] with x hx hs
    rw [hs,Pi.sub_apply,hx,sub_smul,one_smul]
  rw [tendsto_iff_dist_tendsto_zero]
  have hsq : Tendsto (fun n => dist (boundedMul (w n) (hw n) B (hB n) u) u ^2)
      atTop (𝓝 0) := by simpa only [he] using ht
  have hr := hsq.sqrt
  simpa only [Real.sqrt_sq_eq_abs,abs_of_nonneg dist_nonneg,Real.sqrt_zero] using hr

theorem boundedMul_tendsto (w : ℕ → E → ℝ) (hw : ∀ n, AEStronglyMeasurable (w n) μ)
    (B : ℝ) (hB0 : 0 ≤ B) (hB : ∀ n, ∀ᵐ x ∂μ, |w n x| ≤ B)
    (hlim : ∀ᵐ x ∂μ, Tendsto (fun n => w n x) atTop (𝓝 1))
    (f : ℕ → Lp F 2 μ) (u : Lp F 2 μ) (hf : Tendsto f atTop (𝓝 u)) :
    Tendsto (fun n => boundedMul (w n) (hw n) B (hB n) (f n)) atTop (𝓝 u) := by
  let g : ℕ → Lp F 2 μ := fun n => boundedMul (w n) (hw n) B (hB n) u
  let k : ℕ → Lp F 2 μ := fun n => boundedMul (w n) (hw n) B (hB n) (f n)
  have hfixed : Tendsto g atTop (𝓝 u) := boundedMul_fixed_tendsto w hw B hB0 hB hlim u
  have hsmall : Tendsto (fun n => B*dist (f n) u) atTop (𝓝 0) := by
    simpa only [dist_self,mul_zero] using (tendsto_const_nhds (x := B)).mul (hf.dist (tendsto_const_nhds (x := u)))
  have hdist (n : ℕ) : dist (k n) u ≤ B*dist (f n) u + dist (g n) u := by
    have hl : dist (k n) (g n) ≤ B*dist (f n) u :=
      boundedMul_dist_le (w n) (hw n) B hB0 (hB n) (f n) u
    exact (dist_triangle (k n) (g n) u).trans (add_le_add hl (le_refl (dist (g n) u)))
  have hsum : Tendsto (fun n => B*dist (f n) u + dist (g n) u) atTop (𝓝 0) := by
    simpa only [dist_self,zero_add] using hsmall.add (hfixed.dist (tendsto_const_nhds (x := u)))
  exact tendsto_iff_dist_tendsto_zero.mpr (squeeze_zero (fun _ => dist_nonneg) hdist hsum)
end
end BFSSLocalL2

end OAI