import Mathlib

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap

section Ultra
variable {ι : Type*} (ω : Ultrafilter ι)

lemma exists_complex_ultralimit (z : ι → ℂ) (R : ℝ) (hz : ∀ i, ‖z i‖ ≤ R) :
    ∃ c : ℂ, Tendsto z (ω : Filter ι) (𝓝 c) := by
  obtain ⟨c, _, hc⟩ := (isCompact_closedBall (0 : ℂ) R).ultrafilter_le_nhds
    (ω.map z) (by
      rw [Ultrafilter.coe_map, Filter.le_principal_iff]
      change ∀ᶠ i in (ω : Filter ι), z i ∈ Metric.closedBall 0 R
      exact Filter.Eventually.of_forall (fun i => by simpa using hz i))
  exact ⟨c, by
    change Filter.map z (ω : Filter ι) ≤ 𝓝 c
    simpa only [Ultrafilter.coe_map] using hc⟩

variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A]
variable (f : ι → A →ₚ[ℂ] ℂ) (hf : ∀ i a, ‖f i a‖ ≤ ‖a‖)

def ultraValue (a : A) : ℂ :=
  (exists_complex_ultralimit ω (fun i => f i a) ‖a‖ (fun i => hf i a)).choose

lemma tendsto_ultraValue (a : A) :
    Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 (ultraValue ω f hf a)) :=
  (exists_complex_ultralimit ω (fun i => f i a) ‖a‖ (fun i => hf i a)).choose_spec

def ultraPositive : A →ₚ[ℂ] ℂ where
  toFun := ultraValue ω f hf
  map_add' a b := by
    apply tendsto_nhds_unique (tendsto_ultraValue ω f hf (a + b))
    simpa only [map_add] using (tendsto_ultraValue ω f hf a).add
      (tendsto_ultraValue ω f hf b)
  map_smul' c a := by
    apply tendsto_nhds_unique (tendsto_ultraValue ω f hf (c • a))
    simpa only [map_smul, RingHom.id_apply] using (tendsto_ultraValue ω f hf a).const_smul c
  monotone' := by
    intro a b hab
    exact le_of_tendsto_of_tendsto (tendsto_ultraValue ω f hf a)
      (tendsto_ultraValue ω f hf b) (Filter.Eventually.of_forall fun i => (f i).monotone hab)

lemma tendsto_ultraPositive (a : A) :
    Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 (ultraPositive ω f hf a)) :=
  tendsto_ultraValue ω f hf a

lemma ultraPositive_norm_le (a : A) : ‖ultraPositive ω f hf a‖ ≤ ‖a‖ :=
  le_of_tendsto' (tendsto_ultraPositive ω f hf a).norm (fun i => hf i a)

lemma ultraPositive_eq_zero_of_tendsto {a : A}
    (ha : Tendsto (fun i => f i a) (ω : Filter ι) (𝓝 0)) :
    ultraPositive ω f hf a = 0 :=
  tendsto_nhds_unique (tendsto_ultraPositive ω f hf a) ha
end Ultra

section GNS
variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
variable (f : A →ₚ[ℂ] ℂ)

lemma gns_zero_of_sandwich (a : A)
    (ha : ∀ b : A, f (star (a * b) * (a * b)) = 0) :
    f.gnsNonUnitalStarAlgHom a = 0 := by
  ext x
  induction x using UniformSpace.Completion.induction_on with
  | hp => exact isClosed_eq (f.gnsNonUnitalStarAlgHom a).continuous continuous_const
  | ih b =>
    rw [zero_apply, ← norm_eq_zero]
    rw [f.gnsNonUnitalStarAlgHom_apply_coe, UniformSpace.Completion.norm_coe]
    change ‖f.toPreGNS (a * f.ofPreGNS b)‖ = 0
    rw [f.preGNS_norm_def]
    simp only [f.ofPreGNS_toPreGNS, ha, Complex.zero_re, Real.sqrt_zero]

lemma gnsStar_nonzero_of_value {B : Type*} [CStarAlgebra B] [PartialOrder B]
    [StarOrderedRing B] (g : B →ₚ[ℂ] ℂ) (a : B)
    (ha : g (star a * a) ≠ 0) : g.gnsStarAlgHom a ≠ 0 := by
  intro h
  have hx := congrArg (fun T : g.GNS →L[ℂ] g.GNS => T
    (↑(g.toPreGNS 1) : g.GNS)) h
  have hn := congrArg norm hx
  change ‖g.gnsNonUnitalStarAlgHom a (↑(g.toPreGNS 1) : g.GNS)‖ = ‖(0 : g.GNS)‖ at hn
  rw [g.gnsNonUnitalStarAlgHom_apply_coe, UniformSpace.Completion.norm_coe] at hn
  have hab : ‖g.toPreGNS a‖ = 0 := by
    simp only [norm_zero] at hn
    change ‖g.toPreGNS (a * 1)‖ = 0 at hn
    simpa using hn
  have hh := g.preGNS_norm_sq (g.toPreGNS a)
  rw [hab] at hh
  apply ha
  simpa using hh.symm
end GNS

section Vector
variable {A H : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H)

def vectorPositive : A →ₚ[ℂ] ℂ where
  toFun a := ⟪ξ, π a ξ⟫_ℂ
  map_add' a b := by simp
  map_smul' c a := by simp
  monotone' := by
    intro a b hab
    rw [← sub_nonneg, ← inner_sub_right, ← sub_apply, ← map_sub]
    exact ContinuousLinearMap.nonneg_iff_isPositive.mp
      (map_nonneg π (sub_nonneg.mpr hab)) |>.inner_nonneg_right ξ

lemma vectorPositive_norm_le (hξ : ‖ξ‖ ≤ 1) (a : A) :
    ‖vectorPositive π ξ a‖ ≤ ‖a‖ := by
  calc
    ‖vectorPositive π ξ a‖ ≤ ‖ξ‖ * ‖π a ξ‖ := norm_inner_le_norm ξ (π a ξ)
    _ ≤ ‖ξ‖ * (‖a‖ * ‖ξ‖) := mul_le_mul_of_nonneg_left
      ((π a).le_opNorm ξ |>.trans (mul_le_mul_of_nonneg_right
        (NonUnitalStarAlgHom.norm_apply_le π a) (norm_nonneg ξ))) (norm_nonneg ξ)
    _ ≤ 1 * (‖a‖ * 1) := mul_le_mul hξ
      (mul_le_mul_of_nonneg_left hξ (norm_nonneg a)) (by positivity) (by positivity)
    _ = ‖a‖ := by ring

lemma vectorPositive_star_mul (a : A) :
    vectorPositive π ξ (star a * a) = (‖π a ξ‖ ^ 2 : ℝ) := by
  change ⟪ξ, π (star a * a) ξ⟫_ℂ = _
  rw [map_mul, map_star, mul_apply_eq_comp, ContinuousLinearMap.star_eq_adjoint,
    ContinuousLinearMap.adjoint_inner_right, inner_self_eq_norm_sq_to_K, Complex.ofReal_pow]
  rfl
end Vector

section LimitRep
variable {ι A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
variable {H : ι → Type*} [∀ i, NormedAddCommGroup (H i)]
  [∀ i, InnerProductSpace ℂ (H i)] [∀ i, CompleteSpace (H i)]
variable (ω : Ultrafilter ι) (π : ∀ i, A →⋆ₐ[ℂ] (H i →L[ℂ] H i))
  (ξ : ∀ i, H i) (hξ : ∀ i, ‖ξ i‖ ≤ 1)

def limitFunctional : A →ₚ[ℂ] ℂ :=
  ultraPositive ω (fun i => vectorPositive (π i) (ξ i))
    (fun i => vectorPositive_norm_le (π i) (ξ i) (hξ i))

abbrev LimitHilbert := (limitFunctional ω π ξ hξ).GNS

def limitRep : A →⋆ₐ[ℂ] (LimitHilbert ω π ξ hξ →L[ℂ] LimitHilbert ω π ξ hξ) :=
  (limitFunctional ω π ξ hξ).gnsStarAlgHom

lemma limitFunctional_tendsto (a : A) :
    Tendsto (fun i => vectorPositive (π i) (ξ i) a) (ω : Filter ι)
      (𝓝 (limitFunctional ω π ξ hξ a)) := tendsto_ultraPositive _ _ _ _

lemma limitRep_annihilates (a : A)
    (ha : Tendsto (fun i => ‖π i a‖) (ω : Filter ι) (𝓝 0)) :
    limitRep ω π ξ hξ a = 0 := by
  change (limitFunctional ω π ξ hξ).gnsNonUnitalStarAlgHom a = 0
  apply gns_zero_of_sandwich
  intro b
  apply ultraPositive_eq_zero_of_tendsto
  have hh : Tendsto (fun i => ‖π i (a * b) (ξ i)‖) (ω : Filter ι) (𝓝 0) := by
    apply squeeze_zero (fun i => norm_nonneg _) (fun i => ?_)
      (show Tendsto (fun i => ‖π i a‖ * ‖b‖) (ω : Filter ι) (𝓝 0) by
        simpa using ha.mul_const ‖b‖)
    have hmul : ‖π i (a * b)‖ ≤ ‖π i a‖ * ‖b‖ := by
      rw [map_mul]
      exact (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_left
        (NonUnitalStarAlgHom.norm_apply_le (π i) b) (norm_nonneg _))
    calc
      ‖π i (a * b) (ξ i)‖ ≤ ‖π i (a * b)‖ * ‖ξ i‖ := (π i (a * b)).le_opNorm _
      _ ≤ (‖π i a‖ * ‖b‖) * 1 := mul_le_mul hmul (hξ i) (norm_nonneg _) (by positivity)
      _ = ‖π i a‖ * ‖b‖ := mul_one _
  simpa only [vectorPositive_star_mul, zero_pow (by decide : 2 ≠ 0), Complex.ofReal_zero]
    using (hh.pow 2).ofReal

lemma limitRep_nonzero (a : A) {δ : ℝ} (hδ : 0 < δ)
    (ha : ∀ᶠ i in (ω : Filter ι), δ ≤ ‖π i a (ξ i)‖) :
    limitRep ω π ξ hξ a ≠ 0 := by
  apply gnsStar_nonzero_of_value
  have hlim := (Complex.continuous_re.tendsto _).comp
    (limitFunctional_tendsto ω π ξ hξ (star a * a))
  have hle : δ ^ 2 ≤ (limitFunctional ω π ξ hξ (star a * a)).re := by
    apply ge_of_tendsto hlim
    filter_upwards [ha] with i hi
    simp only [Function.comp_apply, vectorPositive_star_mul, Complex.ofReal_re]
    exact pow_le_pow_left₀ hδ.le hi 2
  intro hf
  rw [hf, Complex.zero_re] at hle
  nlinarith [sq_pos_of_pos hδ]
end LimitRep
end MainGap

noncomputable section
open scoped Topology ComplexOrder InnerProductSpace
namespace MainGap

variable {A H : Type*} [CStarAlgebra A]
variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
variable (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (v : A)

def generatedRange : Submodule ℂ H :=
  (Submodule.span ℂ {x | ∃ a : A, ∃ y : H, x = π a (π v y)}).topologicalClosure

instance : CompleteSpace (generatedRange π v) := by
  unfold generatedRange
  infer_instance

lemma range_mem_generatedRange (y : H) : π v y ∈ generatedRange π v := by
  apply Submodule.le_topologicalClosure
  apply Submodule.subset_span
  exact ⟨1, y, by simp⟩

lemma generatedRange_invariant (a : A) :
    ∀ x ∈ generatedRange π v, π a x ∈ generatedRange π v := by
  change generatedRange π v ≤ (generatedRange π v).comap (π a).toLinearMap
  apply Submodule.topologicalClosure_minimal
  · apply Submodule.span_le.mpr
    rintro x ⟨b, y, rfl⟩
    apply Submodule.le_topologicalClosure
    apply Submodule.subset_span
    exact ⟨a * b, y, by simp⟩
  · exact (Submodule.isClosed_topologicalClosure _).preimage (π a).continuous

def rangeRestriction : A →⋆ₐ[ℂ] (generatedRange π v →L[ℂ] generatedRange π v) where
  toFun a := (π a).restrict (generatedRange_invariant π v a)
  map_one' := by ext x; simp [ContinuousLinearMap.restrict]
  map_mul' a b := by ext x; simp [ContinuousLinearMap.restrict]
  map_add' a b := by ext x; simp [ContinuousLinearMap.restrict]
  commutes' c := by ext x; simp [ContinuousLinearMap.restrict, Algebra.algebraMap_eq_smul_one]
  map_zero' := by ext x; simp [ContinuousLinearMap.restrict]
  map_star' a := by
    change (π (star a)).restrict (generatedRange_invariant π v (star a)) =
      ContinuousLinearMap.adjoint ((π a).restrict (generatedRange_invariant π v a))
    apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr
    intro x y
    change ⟪π (star a) (x : H), (y : H)⟫_ℂ = ⟪(x : H), π a (y : H)⟫_ℂ
    rw [map_star, ContinuousLinearMap.star_eq_adjoint,
      ContinuousLinearMap.adjoint_inner_left]

@[simp]
lemma rangeRestriction_apply (a : A) (x : generatedRange π v) :
    ((rangeRestriction π v a x : generatedRange π v) : H) = π a (x : H) := rfl

lemma rangeRestriction_kills (u : A) (hu : ∀ a : A, π u * π a * π v = 0) :
    rangeRestriction π v u = 0 := by
  have hle : generatedRange π v ≤ (π u).ker := by
    apply Submodule.topologicalClosure_minimal
    · apply Submodule.span_le.mpr
      rintro x ⟨a, y, rfl⟩
      change π u (π a (π v y)) = 0
      have := congrArg (fun T : H →L[ℂ] H => T y) (hu a)
      simpa using this
    · exact (π u).isClosed_ker
  ext x
  exact hle x.property

lemma rangeRestriction_nonzero (hv : IsSelfAdjoint v) (hne : π v ≠ 0) :
    rangeRestriction π v v ≠ 0 := by
  intro h
  apply hne
  apply (CStarRing.star_mul_self_eq_zero_iff (π v)).mp
  have hv' : IsSelfAdjoint (π v) := hv.map π
  rw [hv'.star_eq]
  ext y
  have hy := congrArg (fun T : generatedRange π v →L[ℂ] generatedRange π v =>
    T ⟨π v y, range_mem_generatedRange π v y⟩) h
  have := congrArg (fun x : generatedRange π v => (x : H)) hy
  simpa using this

end MainGap

end
end

end OAI