import Mathlib
import OAI.Analysis.Crouzeix.Fourier

namespace OAI

/-! Boundary Operators. -/

noncomputable section

open MeasureTheory

open scoped InnerProductSpace

namespace CrouzeixHilbert.Boundary

local instance boundaryOperatorsFactOnePos : Fact (0 < (1 : ℝ)) := ⟨by norm_num⟩

lemma norm_integral_weight_sq_le {α E : Type*} [MeasurableSpace α]
    [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
    {μ : Measure α} (w : α → ℝ) (u : α → E)
    (hw0 : ∀ᵐ t ∂μ, 0 ≤ w t) (hw : Integrable w μ)
    (hwu : Integrable (fun t => w t • u t) μ)
    (hwu2 : Integrable (fun t => w t * ‖u t‖ ^ 2) μ)
    (hw1 : ∫ t, w t ∂μ = 1) :
    ‖∫ t, w t • u t ∂μ‖ ^ 2 ≤ ∫ t, w t * ‖u t‖ ^ 2 ∂μ := by
  let v := ∫ t, w t • u t ∂μ
  have hi := integral_mono_ae (((hwu.const_inner v)).const_mul 2)
    ((hw.mul_const (‖v‖ ^ 2)).add hwu2) (hw0.mono fun t ht => by
      simp only [Pi.add_apply, real_inner_smul_right]
      have h := sq_nonneg ‖v - u t‖
      rw [norm_sub_sq_real] at h
      nlinarith [mul_nonneg ht h])
  have hv : ∫ t, ⟪v, w t • u t⟫_ℝ ∂μ = ‖v‖ ^ 2 := by
    rw [integral_inner hwu v]
    exact real_inner_self_eq_norm_sq v
  simp only [Pi.add_apply] at hi
  rw [integral_const_mul, hv, integral_add (hw.mul_const _) hwu2,
    integral_mul_const, hw1, one_mul] at hi
  linarith

abbrev CircleKernel := C(CircleSpace × CircleSpace, ℝ)

def kernelApply {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) (x : CircleSpace) : HS k :=
  ∫ y, m (x,y) • u y ∂circleMeasure

lemma boundaryLp_integrable {k : ℕ} (u : BoundaryL2 k) : Integrable u circleMeasure :=
  (Lp.memLp u).integrable (by norm_num)

lemma kernel_integrable {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) (x : CircleSpace) :
    Integrable (fun y => m (x,y) • u y) circleMeasure := by
  have hm : AEStronglyMeasurable (fun y => m (x,y)) circleMeasure :=
    (m.continuous.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  change Integrable ((fun y => m (x,y)) • (u : CircleSpace → HS k)) circleMeasure
  exact Integrable.bdd_smul (𝕜 := ℝ) (boundaryLp_integrable u) ‖m‖ hm
    (Filter.Eventually.of_forall fun y => m.norm_coe_le_norm (x,y))

lemma kernel_sq_integrable {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) (x : CircleSpace) :
    Integrable (fun y => m (x,y) * ‖u y‖ ^ 2) circleMeasure := by
  have hm : AEStronglyMeasurable (fun y => m (x,y)) circleMeasure :=
    (m.continuous.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable
  exact ((Lp.memLp u).norm.integrable_sq).bdd_mul hm
    (Filter.Eventually.of_forall fun y => m.norm_coe_le_norm (x,y))

lemma continuous_kernelApply {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) :
    Continuous (kernelApply m u) := by
  apply continuous_of_dominated (bound := fun y => ‖m‖ * ‖u y‖)
  · intro x
    exact (kernel_integrable m u x).aestronglyMeasurable
  · intro x
    exact Filter.Eventually.of_forall fun y => by
      rw [norm_smul]
      exact mul_le_mul_of_nonneg_right (m.norm_coe_le_norm (x,y)) (norm_nonneg _)
  · exact (boundaryLp_integrable u).norm.const_mul _
  · exact Filter.Eventually.of_forall fun y =>
      (m.continuous.comp (continuous_id.prodMk continuous_const)).smul continuous_const

def kernelLp {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) : BoundaryL2 k :=
  ContinuousMap.toLp 2 circleMeasure ℝ ⟨kernelApply m u, continuous_kernelApply m u⟩

lemma kernelLp_apply_ae {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) :
    kernelLp m u =ᵐ[circleMeasure] kernelApply m u := ContinuousMap.coeFn_toLp _ _

lemma norm_kernelApply_sq_le {k : ℕ} (m : CircleKernel)
    (hm : ∀ x, 0 ≤ m x) (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1)
    (u : BoundaryL2 k) (x : CircleSpace) :
    ‖kernelApply m u x‖ ^ 2 ≤ ∫ y, m (x,y) * ‖u y‖ ^ 2 ∂circleMeasure := by
  apply norm_integral_weight_sq_le (μ := circleMeasure) (fun y => m (x,y)) u
    (Filter.Eventually.of_forall fun y => hm (x,y))
  · exact (m.continuous.comp (continuous_const.prodMk continuous_id)).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _)
  · exact kernel_integrable m u x
  · exact kernel_sq_integrable m u x
  · exact hm1 x

lemma kernel_sq_integrable_prod {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) :
    Integrable (fun z : CircleSpace × CircleSpace => m z * ‖u z.2‖ ^ 2)
      (circleMeasure.prod circleMeasure) :=
  (((Lp.memLp u).norm.integrable_sq).comp_snd circleMeasure).bdd_mul
    m.continuous.aestronglyMeasurable (Filter.Eventually.of_forall m.norm_coe_le_norm)

lemma norm_kernelLp_le {k : ℕ} (m : CircleKernel)
    (hm : ∀ x, 0 ≤ m x) (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) (u : BoundaryL2 k) :
    ‖kernelLp m u‖ ≤ ‖u‖ := by
  have hs : ‖kernelLp m u‖ ^ 2 ≤ ‖u‖ ^ 2 := calc
    _ = ∫ x, ‖kernelLp m u x‖ ^ 2 ∂circleMeasure := lp_norm_sq_eq_integral _
    _ ≤ ∫ x, ∫ y, m (x,y) * ‖u y‖ ^ 2 ∂circleMeasure ∂circleMeasure := by
      apply integral_mono_ae ((Lp.memLp (kernelLp m u)).norm.integrable_sq)
        (kernel_sq_integrable_prod m u).integral_prod_left
      filter_upwards [kernelLp_apply_ae m u] with x hx
      rw [hx]
      exact norm_kernelApply_sq_le m hm hm1 u x
    _ = ∫ y, ∫ x, m (x,y) * ‖u y‖ ^ 2 ∂circleMeasure ∂circleMeasure :=
      integral_integral_swap (kernel_sq_integrable_prod m u)
    _ = ∫ y, ‖u y‖ ^ 2 ∂circleMeasure := by
      apply integral_congr_ae
      exact Filter.Eventually.of_forall fun y => by
        change (∫ x, m (x,y) * ‖u y‖ ^ 2 ∂circleMeasure) = ‖u y‖ ^ 2
        rw [integral_mul_const, hm2, one_mul]
    _ = ‖u‖ ^ 2 := (lp_norm_sq_eq_integral _).symm
  exact (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mp hs

lemma kernelLp_add {k : ℕ} (m : CircleKernel) (u v : BoundaryL2 k) :
    kernelLp m (u + v) = kernelLp m u + kernelLp m v := by
  apply Lp.ext
  filter_upwards [kernelLp_apply_ae m (u+v), kernelLp_apply_ae m u, kernelLp_apply_ae m v,
    Lp.coeFn_add (kernelLp m u) (kernelLp m v)] with x huv hu hv hsum
  simp only [huv, hsum, Pi.add_apply, hu, hv]
  simp only [kernelApply]
  calc
    _ = ∫ y, m (x,y) • u y + m (x,y) • v y ∂circleMeasure := by
      apply integral_congr_ae
      filter_upwards [Lp.coeFn_add u v] with y hy
      simp only [hy, Pi.add_apply, smul_add]
    _ = _ := integral_add (kernel_integrable m u x) (kernel_integrable m v x)

lemma kernelLp_smul {k : ℕ} (m : CircleKernel) (c : ℝ) (u : BoundaryL2 k) :
    kernelLp m (c • u) = c • kernelLp m u := by
  apply Lp.ext
  filter_upwards [kernelLp_apply_ae m (c • u), kernelLp_apply_ae m u,
    Lp.coeFn_smul c (kernelLp m u)] with x hcu hu hsmul
  simp only [hcu, hsmul, Pi.smul_apply, hu]
  simp only [kernelApply]
  calc
    _ = ∫ y, c • (m (x,y) • u y) ∂circleMeasure := by
      apply integral_congr_ae
      filter_upwards [Lp.coeFn_smul c u] with y hy
      rw [hy]
      change m (x,y) • (c • u y) = c • (m (x,y) • u y)
      exact smul_comm _ _ _
    _ = _ := integral_smul c _

def kernelOperator {k : ℕ} (m : CircleKernel)
    (hm : ∀ x, 0 ≤ m x) (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) :
    BoundaryL2 k →L[ℝ] BoundaryL2 k :=
  ({ toFun := kernelLp m
     map_add' := kernelLp_add m
     map_smul' := kernelLp_smul m } : BoundaryL2 k →ₗ[ℝ] BoundaryL2 k).mkContinuous 1
    (fun u => by
      change ‖kernelLp m u‖ ≤ 1 * ‖u‖
      simpa only [one_mul] using norm_kernelLp_le m hm hm1 hm2 u)

lemma norm_kernelOperator_le {k : ℕ} (m : CircleKernel)
    (hm : ∀ x, 0 ≤ m x) (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) :
    ‖kernelOperator (k := k) m hm hm1 hm2‖ ≤ 1 := by
  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
  intro u
  change ‖kernelLp m u‖ ≤ 1 * ‖u‖
  simpa only [one_mul] using norm_kernelLp_le m hm hm1 hm2 u

def transposeKernel (m : CircleKernel) : CircleKernel :=
  ⟨fun z => m z.swap, m.continuous.comp continuous_swap⟩

@[simp] lemma transposeKernel_apply (m : CircleKernel) (x y : CircleSpace) :
    transposeKernel m (x,y) = m (y,x) := rfl

@[simp] lemma transposeKernel_transposeKernel (m : CircleKernel) :
    transposeKernel (transposeKernel m) = m := by
  ext z
  rfl

lemma kernel_inner_integrable {k : ℕ} (m : CircleKernel) (u v : BoundaryL2 k) :
    Integrable (fun z : CircleSpace × CircleSpace => m z * ⟪u z.2, v z.1⟫_ℝ)
      (circleMeasure.prod circleMeasure) := by
  have hints : Integrable (fun z : CircleSpace × CircleSpace =>
      ‖v z.1‖ * ‖u z.2‖) (circleMeasure.prod circleMeasure) :=
    (boundaryLp_integrable v).norm.mul_prod (boundaryLp_integrable u).norm
  have hinner : Integrable (fun z : CircleSpace × CircleSpace => ⟪u z.2, v z.1⟫_ℝ)
      (circleMeasure.prod circleMeasure) := hints.mono'
    (((Lp.aestronglyMeasurable u).comp_snd).inner ((Lp.aestronglyMeasurable v).comp_fst))
    (Filter.Eventually.of_forall fun z => by
      simpa only [mul_comm] using norm_inner_le_norm (𝕜 := ℝ) (u z.2) (v z.1))
  exact hinner.bdd_mul m.continuous.aestronglyMeasurable
    (Filter.Eventually.of_forall m.norm_coe_le_norm)

lemma inner_kernelLp {k : ℕ} (m : CircleKernel) (u v : BoundaryL2 k) :
    ⟪kernelLp m u, v⟫_ℝ =
      ∫ x, ∫ y, m (x,y) * ⟪u y,v x⟫_ℝ ∂circleMeasure ∂circleMeasure := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [kernelLp_apply_ae m u] with x hx
  rw [hx]
  change ⟪∫ y, m (x,y) • u y ∂circleMeasure, v x⟫_ℝ = _
  calc
    _ = ⟪v x, ∫ y, m (x,y) • u y ∂circleMeasure⟫_ℝ := real_inner_comm _ _
    _ = ∫ y, ⟪v x, m (x,y) • u y⟫_ℝ ∂circleMeasure :=
      (integral_inner (kernel_integrable m u x) _).symm
    _ = _ := by
      apply integral_congr_ae
      exact Filter.Eventually.of_forall fun y => by
        change ⟪v x, m (x,y) • u y⟫_ℝ = m (x,y) * ⟪u y,v x⟫_ℝ
        rw [real_inner_smul_right, real_inner_comm]

lemma inner_kernelLp_swap {k : ℕ} (m : CircleKernel) (u v : BoundaryL2 k) :
    ⟪kernelLp m u, v⟫_ℝ = ⟪u, kernelLp (transposeKernel m) v⟫_ℝ := by
  conv_rhs => rw [real_inner_comm]
  rw [inner_kernelLp, inner_kernelLp]
  calc
    _ = ∫ y, ∫ x, m (x,y) * ⟪u y,v x⟫_ℝ ∂circleMeasure ∂circleMeasure :=
      integral_integral_swap (kernel_inner_integrable m u v)
    _ = _ := by
      apply integral_congr_ae
      exact Filter.Eventually.of_forall fun y => by
        apply integral_congr_ae
        exact Filter.Eventually.of_forall fun x => by
          change m (x,y) * ⟪u y,v x⟫_ℝ = transposeKernel m (y,x) * ⟪v x,u y⟫_ℝ
          rw [transposeKernel_apply, real_inner_comm]

lemma adjoint_kernelOperator {k : ℕ} (m : CircleKernel)
    (hm : ∀ x, 0 ≤ m x) (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) :
    ContinuousLinearMap.adjoint (kernelOperator (k := k) m hm hm1 hm2) =
      kernelOperator (transposeKernel m) (fun z => hm z.swap) hm2 hm1 := by
  symm
  apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr
  intro u v
  change ⟪kernelLp (transposeKernel m) u,v⟫_ℝ = ⟪u,kernelLp m v⟫_ℝ
  simpa only [transposeKernel_transposeKernel] using inner_kernelLp_swap (transposeKernel m) u v

lemma kernelLp_star {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) :
    kernelLp m (lpStar u) = lpStar (kernelLp m u) := by
  apply Lp.ext
  filter_upwards [kernelLp_apply_ae m (lpStar u), lpStar_apply_ae (kernelLp m u),
    kernelLp_apply_ae m u] with x hmu hstar hu
  rw [hmu, hstar, hu]
  change (∫ y, m (x,y) • lpStar u y ∂circleMeasure) =
    hsStar k (∫ y, m (x,y) • u y ∂circleMeasure)
  calc
    _ = ∫ y, hsStar k (m (x,y) • u y) ∂circleMeasure := by
      apply integral_congr_ae
      filter_upwards [lpStar_apply_ae u] with y hy
      rw [hy, map_smul]
      rfl
    _ = _ := (hsStar k).toContinuousLinearMap.integral_comp_comm (kernel_integrable m u x)

lemma kernel_integrable_prod {k : ℕ} (m : CircleKernel) (u : BoundaryL2 k) :
    Integrable (fun z : CircleSpace × CircleSpace => m z • u z.2)
      (circleMeasure.prod circleMeasure) := by
  change Integrable ((m : CircleSpace × CircleSpace → ℝ) • (fun z : CircleSpace × CircleSpace => u z.2))
    (circleMeasure.prod circleMeasure)
  exact Integrable.bdd_smul (𝕜 := ℝ) ((boundaryLp_integrable u).comp_snd circleMeasure)
    ‖m‖ m.continuous.aestronglyMeasurable (Filter.Eventually.of_forall m.norm_coe_le_norm)

lemma integral_kernelLp {k : ℕ} (m : CircleKernel)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) (u : BoundaryL2 k) :
    (∫ x, kernelLp m u x ∂circleMeasure) = ∫ y, u y ∂circleMeasure := by
  calc
    _ = ∫ x, ∫ y, m (x,y) • u y ∂circleMeasure ∂circleMeasure :=
      integral_congr_ae (kernelLp_apply_ae m u)
    _ = ∫ y, ∫ x, m (x,y) • u y ∂circleMeasure ∂circleMeasure :=
      integral_integral_swap (kernel_integrable_prod m u)
    _ = _ := by
      apply integral_congr_ae
      exact Filter.Eventually.of_forall fun y => by
        change (∫ x, m (x,y) • u y ∂circleMeasure) = u y
        rw [integral_smul_const, hm2, one_smul]

lemma matrixMean_eq_integral {k : ℕ} (u : BoundaryL2 k) :
    matrixMean u = ofHS (∫ t, u t ∂circleMeasure) := by
  ext i j
  let L : HS k →L[ℂ] ℂ := PiLp.proj 2 (fun _ : Fin k × Fin k => ℂ) (i,j)
  exact L.integral_comp_comm (boundaryLp_integrable u)

lemma matrixMean_kernelLp {k : ℕ} (m : CircleKernel)
    (hm2 : ∀ y, ∫ x, m (x,y) ∂circleMeasure = 1) (u : BoundaryL2 k) :
    matrixMean (kernelLp m u) = matrixMean u := by
  rw [matrixMean_eq_integral, integral_kernelLp m hm2, matrixMean_eq_integral]

lemma kernelLp_const {k : ℕ} (m : CircleKernel)
    (hm1 : ∀ x, ∫ y, m (x,y) ∂circleMeasure = 1) (u : BoundaryL2 k) (v : HS k)
    (hu : u =ᵐ[circleMeasure] fun _ => v) : kernelLp m u = u := by
  apply Lp.ext
  filter_upwards [kernelLp_apply_ae m u, hu] with x hmu hx
  rw [hmu, hx]
  change (∫ y, m (x,y) • u y ∂circleMeasure) = v
  calc
    _ = ∫ y, m (x,y) • v ∂circleMeasure :=
      integral_congr_ae (hu.mono fun y hy => by rw [hy])
    _ = v := by rw [integral_smul_const, hm1, one_smul]

end CrouzeixHilbert.Boundary

end

end OAI