import Mathlib

namespace OAI

/-! Automatic boundedness and integral kernels on Lp spaces. -/

open MeasureTheory
open scoped NNReal ENNReal ContDiff
noncomputable section
open Filter
open scoped Topology ContDiff
open MeasureTheory Set
open scoped ContDiff FourierTransform InnerProductSpace ENNReal
open MeasureTheory Set Filter Metric
open scoped ContDiff Topology
open Set Filter
open scoped ENNReal InnerProductSpace
open scoped FourierTransform SchwartzMap ENNReal
open scoped ENNReal FourierTransform InnerProductSpace
open MeasureTheory Set Filter
open scoped ContDiff Topology ENNReal
open scoped ENNReal NNReal

open Filter
namespace DiagonalExtension.AutomaticBound
variable {α V : Type*} [MeasurableSpace α] {μ : Measure α}
  [NormedAddCommGroup V] [NormedSpace ℂ V] [CompleteSpace V]
  {p : ℝ≥0∞} [Fact (1 ≤ p)]

def pointwiseLpMap (T : α → V →L[ℂ] ℂ)
    (hT : ∀ v, MemLp (fun x => T x v) p μ) : V →ₗ[ℂ] Lp ℂ p μ where
  toFun v := (hT v).toLp (fun x => T x v)
  map_add' v w := by
    apply Lp.ext
    filter_upwards [(hT (v+w)).coeFn_toLp,(hT v).coeFn_toLp,(hT w).coeFn_toLp,
      Lp.coeFn_add ((hT v).toLp _) ((hT w).toLp _)] with x h₁ h₂ h₃ h₄
    exact (h₁.trans ((T x).map_add v w)).trans (by rw [h₄,Pi.add_apply,h₂,h₃])
  map_smul' c v := by
    apply Lp.ext
    filter_upwards [(hT (c • v)).coeFn_toLp,(hT v).coeFn_toLp,
      Lp.coeFn_smul c ((hT v).toLp _)] with x h₁ h₂ h₃
    exact (h₁.trans ((T x).map_smul c v)).trans (by rw [RingHom.id_apply,h₃,Pi.smul_apply,h₂])

theorem continuous_pointwiseLpMap (T : α → V →L[ℂ] ℂ)
    (hT : ∀ v, MemLp (fun x => T x v) p μ) :
    Continuous (pointwiseLpMap T hT) := by
  apply LinearMap.continuous_of_seq_closed_graph
  intro u v w hu hw
  obtain ⟨ns,hmono,hns⟩ := (tendstoInMeasure_of_tendsto_Lp hw).exists_seq_tendsto_ae
  apply Lp.ext
  have hall : ∀ᵐ x ∂μ, ∀ n : ℕ,
      pointwiseLpMap T hT (u (ns n)) x = T x (u (ns n)) := by
    exact ae_all_iff.mpr (fun n => (hT (u (ns n))).coeFn_toLp)
  filter_upwards [hns,hall,(hT v).coeFn_toLp] with x hx hxe hxv
  change w x = (hT v).toLp (fun x => T x v) x
  rw [hxv]
  have he : Tendsto (fun n => T x (u (ns n))) atTop (𝓝 (T x v)) :=
    ((T x).continuous.tendsto v).comp (hu.comp hmono.tendsto_atTop)
  have hw' : Tendsto (fun n => T x (u (ns n))) atTop (𝓝 (w x)) := by
    convert hx using 1
    ext n
    exact (hxe n).symm
  exact tendsto_nhds_unique hw' he

theorem exists_bound (T : α → V →L[ℂ] ℂ)
    (hT : ∀ v, MemLp (fun x => T x v) p μ) :
    ∃ C : ℝ≥0, ∀ v, eLpNorm (fun x => T x v) p μ ≤ (C : ℝ≥0∞) * ‖v‖ₑ := by
  let L : V →L[ℂ] Lp ℂ p μ :=
    ⟨pointwiseLpMap T hT, continuous_pointwiseLpMap T hT⟩
  refine ⟨‖L‖₊,fun v => ?_⟩
  have hb := L.le_opNorm v
  have he := ENNReal.ofReal_le_ofReal hb
  have hv : ‖L v‖ₑ = eLpNorm (fun x => T x v) p μ :=
    Lp.enorm_toLp (hT v)
  rw [← hv, ENNReal.coe_nnreal_eq]
  change ‖L v‖ₑ ≤ ENNReal.ofReal ‖L‖ * ‖v‖ₑ
  simpa only [ENNReal.ofReal_mul (norm_nonneg _),ofReal_norm] using he

end DiagonalExtension.AutomaticBound

open MeasureTheory Filter
open scoped NNReal ENNReal Topology

namespace DiagonalExtension.KernelLp
variable {α : Type*} [MeasurableSpace α] {μ : Measure α} [IsFiniteMeasure μ]
  {p : ℝ≥0∞} [Fact (1 ≤ p)]

lemma integral_norm_le_lp (hp : p ≠ (∞ : ℝ≥0∞)) (f : Lp ℂ p μ) :
    (∫ x, ‖f x‖ ∂μ) ≤ (μ Set.univ ^ (1-1/p.toReal)).toReal * ‖f‖ := by
  have hpr : 1 ≤ p.toReal := by
    simpa using ENNReal.toReal_mono hp (show (1:ℝ≥0∞) ≤ p from Fact.out)
  have hpow : 0 ≤ 1-1/p.toReal := by
    have ht : 0 < p.toReal := by linarith
    have hh : 1/p.toReal ≤ 1 := (div_le_one ht).mpr hpr
    linarith
  have hM : μ Set.univ ^ (1-1/p.toReal) ≠ (∞ : ℝ≥0∞) :=
    ENNReal.rpow_ne_top_of_nonneg hpow (measure_ne_top μ _)
  rw [integral_norm_eq_lintegral_enorm (Lp.aestronglyMeasurable f),
    ← eLpNorm_one_eq_lintegral_enorm (Lp.aestronglyMeasurable f)]
  have hh := eLpNorm_le_eLpNorm_mul_rpow_measure_univ
    (show (1:ℝ≥0∞) ≤ p from Fact.out) (Lp.aestronglyMeasurable f)
  simp only [ENNReal.toReal_one,div_one] at hh
  have hr := ENNReal.toReal_mono (ENNReal.mul_ne_top (Lp.memLp f).eLpNorm_ne_top hM) hh
  simpa only [ENNReal.toReal_mul,← Lp.norm_def,mul_comm] using hr

lemma integrable_kernel {k : α → ℂ} (hk : AEStronglyMeasurable k μ)
    (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ 1) (f : Lp ℂ p μ) :
    Integrable (fun x => f x * k x) μ :=
  ((Lp.memLp f).integrable (show (1:ℝ≥0∞) ≤ p from Fact.out)).mul_bdd hk hb

def evalLinear {k : α → ℂ} (hk : AEStronglyMeasurable k μ)
    (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ 1) : Lp ℂ p μ →ₗ[ℂ] ℂ where
  toFun f := ∫ x, f x * k x ∂μ
  map_add' f g := by
    calc
      _ = ∫ x, f x * k x + g x * k x ∂μ := by
        apply integral_congr_ae
        filter_upwards [Lp.coeFn_add f g] with x hx
        rw [hx,Pi.add_apply,add_mul]
      _ = _ := integral_add (integrable_kernel hk hb f) (integrable_kernel hk hb g)
  map_smul' c f := by
    simp only [RingHom.id_apply]
    calc
      _ = ∫ x, c • (f x * k x) ∂μ := by
        apply integral_congr_ae
        filter_upwards [Lp.coeFn_smul c f] with x hx
        rw [hx,Pi.smul_apply,smul_mul_assoc]
      _ = _ := integral_smul _ _

lemma norm_evalLinear_le (hp : p ≠ (∞ : ℝ≥0∞)) {k : α → ℂ}
    (hk : AEStronglyMeasurable k μ) (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ 1)
    (f : Lp ℂ p μ) :
    ‖evalLinear hk hb f‖ ≤ (μ Set.univ ^ (1-1/p.toReal)).toReal * ‖f‖ := by
  have hi := ((Lp.memLp f).integrable (show (1:ℝ≥0∞) ≤ p from Fact.out)).norm
  apply le_trans (norm_integral_le_of_norm_le hi ?_) (integral_norm_le_lp hp f)
  filter_upwards [hb] with x hx
  exact (norm_mul _ _).le.trans (by simpa using mul_le_mul_of_nonneg_left hx (norm_nonneg (f x)))

def eval (hp : p ≠ (∞ : ℝ≥0∞)) {k : α → ℂ} (hk : AEStronglyMeasurable k μ)
    (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ 1) : Lp ℂ p μ →L[ℂ] ℂ :=
  (evalLinear hk hb).mkContinuous (μ Set.univ ^ (1-1/p.toReal)).toReal
    (norm_evalLinear_le hp hk hb)

@[simp] lemma eval_apply (hp : p ≠ (∞ : ℝ≥0∞)) {k : α → ℂ} (hk : AEStronglyMeasurable k μ)
    (hb : ∀ᵐ x ∂μ, ‖k x‖ ≤ 1) (f : Lp ℂ p μ) :
    eval hp hk hb f = ∫ x, f x * k x ∂μ := rfl

end DiagonalExtension.KernelLp

end

end OAI