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