import OAI.Analysis.CStarAlgebra.PureInfiniteness.IdealComparison

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance signalCutPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance signalCutStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A

lemma Her_cut_lower {a : A} (ha : 0 ≤ a) {δ : ℝ} (hδ : 0 ≤ δ)
    {p : A} (hp : p ∈ Her (cut a δ)) :
    δ • (star p * p) ≤ star p * a * p := by
  have hc : IsClosed {p : A | δ • (star p * p) ≤ star p * a * p} :=
    isClosed_le (by fun_prop) (by fun_prop)
  apply closure_minimal (s := Set.range (fun w : A => cut a δ * w * star (cut a δ))) _ hc hp
  rintro _ ⟨w, rfl⟩
  change δ • (star (cut a δ * w * star (cut a δ)) *
      (cut a δ * w * star (cut a δ))) ≤
    star (cut a δ * w * star (cut a δ)) * a * (cut a δ * w * star (cut a δ))
  have hh := star_left_conjugate_le_conjugate (cut_sandwich_lower ha.isSelfAdjoint hδ)
    (w * cut a δ)
  simpa only [star_mul, (cut_nonneg a δ).isSelfAdjoint.star_eq,
    mul_smul_comm, smul_mul_assoc, mul_assoc] using hh

lemma norm_cut_le_sub {a : A} (ha : 0 ≤ a) {M δ : ℝ} (han : ‖a‖ ≤ M)
    (hδ : δ ≤ M) : ‖cut a δ‖ ≤ M - δ := by
  apply norm_cfcₙ_le
  intro t ht
  have htM : t ≤ M := (le_abs_self t).trans
    ((NonUnitalIsometricContinuousFunctionalCalculus.norm_quasispectrum_le a ht ha.isSelfAdjoint).trans han)
  rw [Real.norm_eq_abs, abs_of_nonneg (le_max_right _ _)]
  exact max_le (by linarith) (sub_nonneg.mpr hδ)

lemma cut_eq_zero_of_norm_le_nonunital {a : A} (ha : 0 ≤ a) {δ : ℝ} (haδ : ‖a‖ ≤ δ) :
    cut a δ = 0 := by
  apply norm_eq_zero.mp
  exact le_antisymm (by simpa using norm_cut_le_sub ha haδ le_rfl) (norm_nonneg _)

end MainGap

namespace MainGap
universe u
variable {A : Type u} [NonUnitalCStarAlgebra A]
local instance signalComparisonPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance signalComparisonStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance signalOperatorPartialOrder (H : Type*) [NormedAddCommGroup H]
    [InnerProductSpace ℂ H] [CompleteSpace H] :
    PartialOrder (H →L[ℂ] H) := CStarAlgebra.spectralOrder _
local instance signalOperatorStarOrderedRing (H : Type*) [NormedAddCommGroup H]
    [InnerProductSpace ℂ H] [CompleteSpace H] :
    StarOrderedRing (H →L[ℂ] H) := CStarAlgebra.spectralOrderedRing _

lemma signal_cut_comparison (hP : PropertyP A) {a p : A} (ha : 0 ≤ a) {δ : ℝ}
    (hδ : 0 < δ) (hpH : p ∈ Her (ramp a δ (2*δ)))
    (hsignal : NormSignal (ramp a δ (2*δ)) p) :
    ScalarCuntzLE (cut a (2*δ)) (star p * a * p) := by
  let v := star p * a * p
  have hv : 0 ≤ v := star_left_conjugate_nonneg ha p
  let V : Unitization ℂ A := Unitization.inr v
  have hV : 0 ≤ V := Unitization.inr_nonneg_iff.mpr hv
  let J := closedIdeal V hV.isSelfAdjoint
  have hcut : (Unitization.inr (cut a (2*δ)) : Unitization ℂ A) ∈ J := by
    by_contra hh
    obtain ⟨R,hRJ,hRcut⟩ := exists_rep_killing_ideal J
      (closedIdeal_closed V hV.isSelfAdjoint)
      (fun x z hz => closedIdeal_left hV.isSelfAdjoint hz x)
      (fun x z hz => closedIdeal_right hV.isSelfAdjoint hz x) hh
    let π := R.hom.toNonUnitalStarAlgHom.comp (Unitization.inrNonUnitalStarAlgHom ℂ A)
    have hvzero : π v = 0 := hRJ V (self_mem_closedIdeal V hV.isSelfAdjoint)
    have hlower := Her_cut_lower ha hδ.le
      (Her_mono_of_mem (ramp_mem_Her_cut ha hδ.le) hpH)
    have hpos := map_nonneg π (sub_nonneg.mpr hlower)
    have hsmul (r : ℝ) (z : A) : π (r • z)=r • π z :=
      LinearMapClass.map_smul_of_tower π r z
    change 0 ≤ π (v - δ • (star p * p)) at hpos
    rw [map_sub, hvzero, hsmul, map_mul, map_star] at hpos
    have hz : δ • (star (π p) * π p) = 0 :=
      le_antisymm (by simpa only [zero_sub, neg_nonneg] using hpos)
        (smul_nonneg hδ.le (star_mul_self_nonneg _))
    have hpzero : π p = 0 := (CStarRing.star_mul_self_eq_zero_iff _).mp
      ((smul_eq_zero.mp hz).resolve_left hδ.ne')
    have hnorm : 2*δ < ‖π a‖ := by
      by_contra! hn
      apply hRcut
      change π (cut a (2*δ)) = 0
      rw [map_cut π ha (by positivity), cut_eq_zero_of_norm_le (map_nonneg π ha) hn]
    have hramp : ‖π (ramp a δ (2*δ))‖ = 1 := by
      rw [map_ramp π ha hδ.le]
      exact norm_ramp_eq_one (map_nonneg π ha) hδ.le (by linarith) hnorm.le
    have hpn := hsignal R (by change (1/2:ℝ) < ‖π (ramp a δ (2*δ))‖; rw [hramp]; norm_num)
    change ‖π p‖ = 1 at hpn
    rw [hpzero, norm_zero] at hpn
    norm_num at hpn
  apply scalarCuntzLE_of_inr hv
  exact closedIdeal_comparison (Unitization.inr_nonneg_iff.mpr (cut_nonneg _ _)) hV
    ((hP v hv).map (Unitization.inrNonUnitalStarAlgHom ℂ A)) hcut

end MainGap

namespace MainGap
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance signalCoefficientPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance signalCoefficientStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A

lemma signal_coefficient (hP : PropertyP A) {a p : A} (ha : 0 ≤ a) (han : ‖a‖ ≤ 1)
    {δ ρ : ℝ} (hδ : 0 < δ) (hδhalf : δ < 1/2) (hρ : 0 < ρ) (hρδ : ρ ≤ 2*δ)
    (hpH : p ∈ Her (ramp a δ (2*δ))) (hsignal : NormSignal (ramp a δ (2*δ)) p) :
    ∃ w : A, ‖star (p*w)*a*(p*w)-a‖ < 2*δ+ρ ∧
      ‖p*w‖ ≤ Real.sqrt δ⁻¹ := by
  have hcomp := signal_cut_comparison hP ha hδ hpH hsignal
  obtain ⟨w,hw⟩ := hcomp.exists_approx hρ
  have hw' : ‖star (p*w)*a*(p*w) - cut a (2*δ)‖ < ρ := by
    simpa only [star_mul, mul_assoc] using hw
  refine ⟨w, ?_, ?_⟩
  · calc
      ‖star (p*w)*a*(p*w)-a‖ ≤
          ‖star (p*w)*a*(p*w)-cut a (2*δ)‖ + ‖cut a (2*δ)-a‖ := by simpa only [dist_eq_norm] using dist_triangle (star (p*w)*a*(p*w)) (cut a (2*δ)) a
      _ < ρ + 2*δ := add_lt_add_of_lt_of_le hw'
        (by simpa only [norm_sub_rev] using norm_sub_cut_le ha (by positivity : 0 ≤ 2*δ))
      _ = 2*δ+ρ := by ring
  · have hlower := star_left_conjugate_le_conjugate
      (Her_cut_lower ha hδ.le (Her_mono_of_mem (ramp_mem_Her_cut ha hδ.le) hpH)) w
    have hlower' : δ • (star (p*w)*(p*w)) ≤ star (p*w)*a*(p*w) := by
      simpa only [star_mul, mul_smul_comm, smul_mul_assoc, mul_assoc] using hlower
    have hn := CStarAlgebra.norm_le_norm_of_le_of_nonneg hlower'
      (smul_nonneg hδ.le (star_mul_self_nonneg (p*w)))
    simp only [norm_smul, Real.norm_eq_abs, abs_of_pos hδ, CStarRing.norm_star_mul_self] at hn
    have hupper : ‖star (p*w)*a*(p*w)‖ < 1 := by
      calc
        ‖star (p*w)*a*(p*w)‖ ≤
            ‖star (p*w)*a*(p*w)-cut a (2*δ)‖ + ‖cut a (2*δ)‖ := norm_le_norm_sub_add _ _
        _ < ρ + (1-2*δ) := add_lt_add_of_lt_of_le hw'
          (norm_cut_le_sub ha han (by linarith))
        _ ≤ 1 := by linarith
    have hsq : ‖p*w‖ ^ 2 ≤ δ⁻¹ := by
      have hh : δ * (‖p*w‖ ^ 2) ≤ 1 := by nlinarith
      have hh' := (le_inv_mul_iff₀ hδ).mpr hh
      simpa only [mul_one] using hh'
    have hsqrt := Real.sq_sqrt (inv_nonneg.mpr hδ.le)
    nlinarith [Real.sqrt_nonneg δ⁻¹, norm_nonneg (p*w)]

end MainGap

namespace MainGap
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance signalProductsPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance signalProductsStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A

lemma HerCompression.right_products {p q c : A} {κ : ℝ} (hκ : 0 ≤ κ)
    (hp : 0 ≤ p) (hq : 0 ≤ q) (h : HerCompression p q c κ) (w z : A) :
    ‖star (p*w) * c * (q*z)‖ ≤ κ * ‖p*w‖ * ‖q*z‖ := by
  let : PartialOrder (Her p) := CStarAlgebra.spectralOrder _
  let : StarOrderedRing (Her p) := CStarAlgebra.spectralOrderedRing _
  let : PartialOrder (Her q) := CStarAlgebra.spectralOrder _
  let : StarOrderedRing (Her q) := CStarAlgebra.spectralOrderedRing _
  let ap := CStarAlgebra.increasingApproximateUnit (Her p)
  let aq := CStarAlgebra.increasingApproximateUnit (Her q)
  let pp : Her p := ⟨p, self_mem_Her hp⟩
  let qq : Her q := ⟨q, self_mem_Her hq⟩
  have htp : Tendsto (fun e : Her p => (e : A) * (p*w))
      (CStarAlgebra.approximateUnit (Her p)) (𝓝 (p*w)) := by
    have hh := ((continuous_subtype_val.tendsto pp).comp (ap.tendsto_mul_right pp)).mul
      (tendsto_const_nhds (x := w))
    change Tendsto (fun e : Her p => ((e : A) * p) * w) _ (𝓝 (p*w)) at hh
    simpa only [mul_assoc] using hh
  have htq : Tendsto (fun e : Her q => (e : A) * (q*z))
      (CStarAlgebra.approximateUnit (Her q)) (𝓝 (q*z)) := by
    have hh := ((continuous_subtype_val.tendsto qq).comp (aq.tendsto_mul_right qq)).mul
      (tendsto_const_nhds (x := z))
    change Tendsto (fun e : Her q => ((e : A) * q) * z) _ (𝓝 (q*z)) at hh
    simpa only [mul_assoc] using hh
  have ht := ((htp.comp tendsto_fst).star.mul (tendsto_const_nhds (x := c))).mul
    (htq.comp tendsto_snd)
  apply le_of_tendsto ht.norm
  filter_upwards [ap.eventually_norm.prod_mk aq.eventually_norm] with ef hef
  rcases ef with ⟨e,f⟩
  change ‖star ((e : A)*(p*w))*c*((f : A)*(q*z))‖ ≤ _
  have he : ‖(e : A)‖ ≤ 1 := hef.1
  have hf : ‖(f : A)‖ ≤ 1 := hef.2
  calc
    ‖star ((e : A)*(p*w))*c*((f : A)*(q*z))‖ =
        ‖star (p*w) * (star (e : A)*c*(f : A)) * (q*z)‖ := by
      simp only [star_mul, mul_assoc]
    _ ≤ ‖p*w‖ * ‖star (e : A)*c*(f : A)‖ * ‖q*z‖ := by
      grw [norm_mul_le, norm_mul_le, norm_star]
    _ ≤ ‖p*w‖ * (κ*‖(e : A)‖*‖(f : A)‖) * ‖q*z‖ := by
      gcongr
      simpa only [norm_star] using h (star (e : A)) (star_mem e.property) (f : A) f.property
    _ ≤ ‖p*w‖ * (κ*1*1) * ‖q*z‖ := by gcongr
    _ = κ * ‖p*w‖ * ‖q*z‖ := by ring

end MainGap

end

end OAI