import OAI.Analysis.CStarAlgebra.PureInfiniteness.Compression

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap
universe u v
variable {A : Type u} [CStarAlgebra A]
local instance shrinkingPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance shrinkingStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance shrinkingOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
local instance shrinkingOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _

theorem conditional_shrinking {a y c p : A} (_ha : 0 ≤ a) (hy : 0 ≤ y)
    (hp : 0 ≤ p) (hpn : ‖p‖ ≤ 1) (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
    (hpH : p ∈ Her a)
    (hsignal : ∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p‖=1)
    (hvan : ∀ R : HilbertRep.{u,u} A,
      R.hom (y*(1-star c*(p*p)*c)*y)=0 → ‖R.hom y‖ ≤ (1/4:ℝ)) :
    ∃ (p₁ q₁ : A) (κ : ℝ), 0 ≤ p₁ ∧ ‖p₁‖ ≤ 1 ∧ p₁ ∈ Her a ∧
      0 ≤ q₁ ∧ ‖q₁‖ ≤ 1 ∧ q₁ ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
      HerCompression p₁ q₁ c κ ∧
      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p₁‖=1) ∧
      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom y‖ → ‖R.hom q₁‖=1) := by
  obtain ⟨δ,hδ,hδ₁,hquant⟩ := quantitative_nonvanishing hy hvan
  let d := y*(1-star c*(p*p)*c)*y
  have hd : 0 ≤ d := (conditional_defect_bounds hp hy hpn hyn hcn).1
  let q := y*cut d δ*y
  have hq : 0 ≤ q := by
    simpa only [hy.isSelfAdjoint.star_eq] using star_left_conjugate_nonneg (cut_nonneg d δ) y
  have hqH : q ∈ Her y := by
    simpa only [hy.isSelfAdjoint.star_eq] using sandwich_mem_Her y (cut d δ)
  have hqvan (R : HilbertRep.{u,u} A) (hz : R.hom q=0) : ‖R.hom y‖ ≤ (3/8:ℝ) := by
    have hqzero : R.hom y * cut (R.hom y*(1-star (R.hom c)*(R.hom p*R.hom p)*R.hom c)*R.hom y) δ * R.hom y=0 := by
      change R.hom (y*cut d δ*y)=0 at hz
      rw [map_mul, map_mul, map_cut_sa R.hom hd.isSelfAdjoint hδ.le] at hz
      simpa only [d, map_mul, map_sub, map_one, map_star] using hz
    have hb := conditional_q_zero (map_nonneg R.hom hp) (map_nonneg R.hom hy)
      ((NonUnitalStarAlgHom.norm_apply_le R.hom p).trans hpn)
      ((NonUnitalStarAlgHom.norm_apply_le R.hom y).trans hyn)
      ((NonUnitalStarAlgHom.norm_apply_le R.hom c).trans hcn) hδ hqzero
    have hb' : ‖R.hom d‖ ≤ δ := by
      simpa only [d, map_mul, map_sub, map_one, map_star] using hb
    by_contra! hRy
    exact (not_lt_of_ge hb') (hquant R hRy)
  obtain ⟨δ',hδ',hδ'₁,hquant'⟩ := quantitative_nonvanishing_general hy
    (by norm_num : (0:ℝ)≤3/8) (by norm_num : (3/8:ℝ)<1/2) hqvan
  let r := Real.sqrt (1-δ)
  have hr : 0 ≤ r := Real.sqrt_nonneg _
  have hr₁ : r < 1 := by
    apply (Real.sqrt_lt' (by norm_num : (0:ℝ)<1)).mpr
    linarith
  let τ := (r+1)/2
  have hτ : 0 < τ := by dsimp [τ]; linarith
  have hrτ : r < τ := by dsimp [τ]; linarith
  have hτ₁ : τ < 1 := by dsimp [τ]; linarith
  let p₁ := ramp p τ 1
  let q₁ := ramp q (δ'/2) δ'
  have hp₁ : 0 ≤ p₁ := ramp_nonneg p hτ₁.le
  have hq₁ : 0 ≤ q₁ := ramp_nonneg q (by linarith)
  have hq₁H : q₁ ∈ Her q :=
    Her_mono_of_mem (cut_mem_Her hq (δ'/2)) (ramp_mem_Her_cut hq (by positivity))
  refine ⟨p₁,q₁,r/τ,hp₁,norm_ramp_le_one p hτ₁.le,?_,hq₁,
    norm_ramp_le_one q (by linarith),Her_mono_of_mem hqH hq₁H,
    div_nonneg hr hτ.le,(div_lt_one hτ).mpr hrτ,?_,?_,?_⟩
  · exact Her_mono_of_mem hpH (Her_mono_of_mem (cut_mem_Her hp τ) (ramp_mem_Her_cut hp hτ.le))
  · have hcomp := compression_of_conditional_loss hp hτ hr (conditional_Her_loss hp hy hpn hyn hcn hδ.le hδ₁.le)
    intro x hx k hk
    exact hcomp x hx k (Her_mono_of_mem hq₁H hk)
  · intro R hRa
    change ‖R.hom (ramp p τ 1)‖=1
    rw [map_ramp_sa R.hom hp.isSelfAdjoint hτ.le]
    exact norm_ramp_eq_one (map_nonneg R.hom hp) hτ.le hτ₁ (by rw [hsignal R hRa])
  · intro R hRy
    change ‖R.hom (ramp q (δ'/2) δ')‖=1
    rw [map_ramp_sa R.hom hq.isSelfAdjoint (by positivity)]
    exact norm_ramp_eq_one (map_nonneg R.hom hq) (by positivity) (by linarith) (hquant' R hRy).le

theorem shrinking_unital_local {a y c : A} (ha : 0 ≤ a) (hy : 0 ≤ y)
    (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1)
    (hp : ∀ z : A, 0 ≤ z → z ∈ Her a → ProperlyInfinite z) :
    ∃ (p q : A) (κ : ℝ), 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
      HerCompression p q c κ ∧
      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom a‖ → ‖R.hom p‖=1) ∧
      (∀ R : HilbertRep.{u,u} A, (1/2:ℝ)<‖R.hom y‖ → ‖R.hom q‖=1) := by
  obtain ⟨p,hpp,hpn,hpH,hsignal,hvan⟩ := graph_nonvanishing.{u,u} ha hy hcn hp
  exact conditional_shrinking ha hy hpp hpn hyn hcn hpH hsignal hvan

end MainGap

namespace MainGap
variable {A B : Type*} [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B]

def matrixMap (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ} (x : CStarMatrix (Fin m) (Fin n) A) :
    CStarMatrix (Fin m) (Fin n) B := CStarMatrix.ofMatrix (fun i j => π (x i j))

lemma matrixMap_mul (π : A →⋆ₙₐ[ℂ] B) {l m n : ℕ}
    (x : CStarMatrix (Fin l) (Fin m) A) (y : CStarMatrix (Fin m) (Fin n) A) :
    matrixMap π (x*y)=matrixMap π x * matrixMap π y := by
  ext i j
  change π (∑ k, x i k * y k j) = ∑ k, π (x i k) * π (y k j)
  simp only [map_sum, map_mul]

lemma matrixMap_star (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ}
    (x : CStarMatrix (Fin m) (Fin n) A) :
    matrixMap π x.conjTranspose=(matrixMap π x).conjTranspose := by
  ext i j
  change π (star (x j i)) = star (π (x j i))
  exact map_star π _

lemma continuous_matrixMap (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ} :
    Continuous (matrixMap π : CStarMatrix (Fin m) (Fin n) A → CStarMatrix (Fin m) (Fin n) B) := by
  apply continuous_pi
  intro i
  apply continuous_pi
  intro j
  exact (map_continuous π).comp ((continuous_apply j).comp (continuous_apply i))

lemma FiniteCuntzLE.map (π : A →⋆ₙₐ[ℂ] B) {m n : ℕ}
    {d : CStarMatrix (Fin n) (Fin n) A} {v : CStarMatrix (Fin m) (Fin m) A}
    (h : FiniteCuntzLE d v) : FiniteCuntzLE (matrixMap π d) (matrixMap π v) := by
  obtain ⟨r,ht⟩ := h
  refine ⟨fun j => matrixMap π (r j), ?_⟩
  have he := (continuous_matrixMap π).continuousAt.tendsto.comp ht
  change Tendsto (fun j => matrixMap π ((r j).conjTranspose * v * r j)) atTop (𝓝 (matrixMap π d)) at he
  simpa only [matrixMap_mul, matrixMap_star] using he

lemma ProperlyInfinite.map (π : A →⋆ₙₐ[ℂ] B) {h : A} (hh : ProperlyInfinite h) :
    ProperlyInfinite (π h) := by
  have he := FiniteCuntzLE.map π hh
  have hdouble : matrixMap π (doubleCorner h)=doubleCorner (π h) := by
    ext i j
    change π (if i=j then h else 0) = if i=j then π h else 0
    split_ifs <;> simp
  have hsingle : matrixMap π (scalarCorner h)=scalarCorner (π h) := rfl
  change FiniteCuntzLE _ _
  rwa [hdouble, hsingle] at he

end MainGap

namespace MainGap
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance shrinkingHerPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance shrinkingHerStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance shrinkingHerUnitizationPartialOrder : PartialOrder (Unitization ℂ A) :=
  CStarAlgebra.spectralOrder _
local instance shrinkingHerUnitizationStarOrderedRing : StarOrderedRing (Unitization ℂ A) :=
  CStarAlgebra.spectralOrderedRing _

lemma unitization_Her {a : A} {z : Unitization ℂ A}
    (hz : z ∈ Her (a : Unitization ℂ A)) : z.fst=0 ∧ z.snd ∈ Her a := by
  have hc : IsClosed {z : Unitization ℂ A | z.fst=0 ∧ z.snd ∈ Her a} :=
    (isClosed_eq Unitization.continuous_fst continuous_const).inter
      ((isClosed_Her a).preimage Unitization.continuous_snd)
  apply closure_minimal (s := Set.range (fun b : Unitization ℂ A =>
    (a : Unitization ℂ A)*b*star (a : Unitization ℂ A))) _ hc hz
  rintro z ⟨b,rfl⟩
  constructor
  · simp
  · change ((a : Unitization ℂ A)*b*star (a : Unitization ℂ A)).snd ∈ Her a
    have he : ((a : Unitization ℂ A)*b*star (a : Unitization ℂ A)).snd =
        b.fst • (a*star a) + a*b.snd*star a := by
      simp [Unitization.snd_mul, Unitization.fst_mul, add_mul, smul_mul_assoc]
    rw [he]
    exact (Her a).add_mem ((Her a).smul_mem b.fst (mul_star_mem_Her a)) (sandwich_mem_Her a b.snd)

lemma unitization_inr_snd_of_Her {a : A} {z : Unitization ℂ A}
    (hz : z ∈ Her (a : Unitization ℂ A)) : (z.snd : Unitization ℂ A)=z := by
  have he := Unitization.inl_fst_add_inr_snd_eq z
  simpa only [(unitization_Her hz).1, Unitization.inl_zero, zero_add] using he

lemma unitization_proper_hereditary (hp : PropertyP A) {a : A}
    {z : Unitization ℂ A} (hz : 0 ≤ z) (hzH : z ∈ Her (a : Unitization ℂ A)) :
    ProperlyInfinite z := by
  have he := unitization_inr_snd_of_Her hzH
  have hz' : 0 ≤ z.snd := Unitization.inr_nonneg_iff.mp (he.symm ▸ hz)
  have hh := (hp z.snd hz').map (Unitization.inrNonUnitalStarAlgHom ℂ A)
  change ProperlyInfinite (z.snd : Unitization ℂ A) at hh
  rwa [he] at hh

end MainGap

namespace MainGap
universe u
variable {A : Type u} [NonUnitalCStarAlgebra A]
local instance shrinkingNonunitalPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance shrinkingNonunitalStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance shrinkingNonunitalUnitizationPartialOrder : PartialOrder (Unitization ℂ A) :=
  CStarAlgebra.spectralOrder _
local instance shrinkingNonunitalUnitizationStarOrderedRing : StarOrderedRing (Unitization ℂ A) :=
  CStarAlgebra.spectralOrderedRing _

def NormSignal (a p : A) : Prop :=
  ∀ R : HilbertRep.{u,u} (Unitization ℂ A), (1/2:ℝ)<‖R.hom (a : Unitization ℂ A)‖ →
    ‖R.hom (p : Unitization ℂ A)‖=1

theorem shrinking_nonunital (hp : PropertyP A) {a y c : A} (ha : 0 ≤ a) (hy : 0 ≤ y)
    (hyn : ‖y‖ ≤ 1) (hcn : ‖c‖ ≤ 1) :
    ∃ (p q : A) (κ : ℝ), 0 ≤ p ∧ ‖p‖ ≤ 1 ∧ p ∈ Her a ∧
      0 ≤ q ∧ ‖q‖ ≤ 1 ∧ q ∈ Her y ∧ 0 ≤ κ ∧ κ < 1 ∧
      HerCompression p q c κ ∧ NormSignal a p ∧ NormSignal y q := by
  obtain ⟨p,q,κ,hp0,hpn,hpH,hq0,hqn,hqH,hκ0,hκ1,hcomp,hps,hqs⟩ :=
    shrinking_unital_local (Unitization.inr_nonneg_iff.mpr ha)
      (Unitization.inr_nonneg_iff.mpr hy)
      (by simpa only [Unitization.norm_inr] using hyn : ‖(y : Unitization ℂ A)‖ ≤ 1)
      (by simpa only [Unitization.norm_inr] using hcn : ‖(c : Unitization ℂ A)‖ ≤ 1)
      (fun z hz hzH => unitization_proper_hereditary hp hz hzH)
  have hep := unitization_inr_snd_of_Her hpH
  have heq := unitization_inr_snd_of_Her hqH
  refine ⟨p.snd,q.snd,κ,Unitization.inr_nonneg_iff.mp (hep.symm ▸ hp0),?_,
    (unitization_Her hpH).2,Unitization.inr_nonneg_iff.mp (heq.symm ▸ hq0),?_,
    (unitization_Her hqH).2,hκ0,hκ1,?_,?_,?_⟩
  · have hn : ‖p.snd‖=‖p‖ := by simpa only [Unitization.norm_inr] using congrArg norm hep
    rwa [hn]
  · have hn : ‖q.snd‖=‖q‖ := by simpa only [Unitization.norm_inr] using congrArg norm heq
    rwa [hn]
  · intro x hx k hk
    have hx' := Her_map (Unitization.inrNonUnitalStarAlgHom ℂ A) hx
    have hk' := Her_map (Unitization.inrNonUnitalStarAlgHom ℂ A) hk
    change (x : Unitization ℂ A) ∈ Her (p.snd : Unitization ℂ A) at hx'
    change (k : Unitization ℂ A) ∈ Her (q.snd : Unitization ℂ A) at hk'
    rw [hep] at hx'
    rw [heq] at hk'
    have hb := hcomp _ hx' _ hk'
    simpa only [← Unitization.inr_mul, Unitization.norm_inr] using hb
  · intro R hRa
    rw [hep]
    exact hps R hRa
  · intro R hRy
    rw [heq]
    exact hqs R hRy
end MainGap

end

end OAI