import OAI.Analysis.CStarAlgebra.PureInfiniteness.FourChoices

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

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

lemma deficiency_eq_sub {d : A} (hd : 0 ≤ d) (hb : d ≤ (1/2 : ℝ) • (1 : A)) :
    deficiency d = (1/2 : ℝ) • (1 : A) - d := by
  have hdsa : IsSelfAdjoint d := .of_nonneg hd
  have hb' : cfc (fun t : ℝ => t) d ≤ cfc (fun _ : ℝ => (1/2 : ℝ)) d := by
    rw [cfc_id' ℝ d hdsa, cfc_const (1/2 : ℝ) d hdsa, Algebra.algebraMap_eq_smul_one]
    exact hb
  have hs := (cfc_le_iff _ _ d continuousOn_id continuousOn_const hdsa).mp hb'
  calc
    deficiency d = cfc (fun t : ℝ => (1/2 : ℝ)-t) d := by
      apply cfc_congr
      intro t ht
      exact max_eq_left (sub_nonneg.mpr (hs t ht))
    _ = cfc (fun _ : ℝ => (1/2 : ℝ)) d - cfc (fun t : ℝ => t) d :=
      cfc_sub _ _ d continuousOn_const continuousOn_id
    _ = (1/2 : ℝ) • (1 : A) - d := by
      rw [cfc_const (1/2 : ℝ) d hdsa, cfc_id' ℝ d hdsa, Algebra.algebraMap_eq_smul_one]

lemma sandwich_zero_eigen {x d : A} (hx : 0 ≤ x) (hd : 0 ≤ d)
    (hdle : d ≤ (1/2 : ℝ) • (1 : A))
    (hU : x * deficiency d * deficiency d * x = 0) : d * x = (1/2 : ℝ) • x := by
  have hQx : deficiency d * x = 0 := by
    apply (CStarRing.star_mul_self_eq_zero_iff _).mp
    simpa only [star_mul, IsSelfAdjoint.of_nonneg hx |>.star_eq,
      deficiency_selfAdjoint d |>.star_eq, mul_assoc] using hU
  rw [deficiency_eq_sub hd hdle, sub_mul, smul_mul_assoc, one_mul] at hQx
  exact (sub_eq_zero.mp hQx).symm

lemma Her_eigen_left {x d k : A} {h : ℝ} (hx : d*x=h•x) (hk : k ∈ Her x) :
    d*k=h•k := by
  have hz : (d-h • (1:A))*x=0 := by
    simp only [sub_mul, smul_mul_assoc, one_mul, hx, sub_self]
  have := Her_killed_left hz hk
  simpa only [sub_mul, smul_mul_assoc, one_mul, sub_eq_zero] using this

lemma firstH_mem_firstX {X : A} (hX : 0 ≤ X) : firstH X ∈ Her (firstX X) :=
  Her_mono_of_mem (cut_mem_cutHer hX (by norm_num : (0:ℝ) ≤ 1/16)
    (by norm_num : (1/16:ℝ) ≤ 3/32)) (ramp_mem_Her_cut hX (by norm_num))

lemma firstK_fixes_H {X : A} (hX : 0 ≤ X) : firstK X * firstH X = firstH X :=
  Her_fixed_left (ramp_mul_cut hX (by norm_num : (0:ℝ) ≤ 3/64)
    (by norm_num : (3/64:ℝ) < 1/16) le_rfl) (firstH_mem_firstX hX)

lemma firstR_fixed_left {X B : A} (hX : 0 ≤ X) (hB : star B * B ∈ Her (firstV X)) :
    firstH X * firstR X B = firstR X B := by
  have hstar : firstH X * star B = star B := by
    apply fixed_left_of_modulus
    simp only [star_star]
    exact Her_fixed_left (firstH_fixes_V hX) hB
  simp only [firstR, mul_smul_comm, ← mul_assoc, hstar]

lemma firstR_inner {X B C : A} (hmod : B * star C = B * star B)
    (hDH : B * star B * firstH X = (1/2 : ℝ) • firstH X) :
    star (firstR X B) * firstR X C = firstH X * firstH X := by
  have hH : star (firstH X) = firstH X := (IsSelfAdjoint.of_nonneg (ramp_nonneg X (by norm_num : (3/32:ℝ) ≤ 1/8))).star_eq
  simp only [firstR, star_smul, star_trivial, star_mul, hH, star_star,
    smul_mul_smul]
  rw [Real.mul_self_sqrt (by norm_num : (0:ℝ) ≤ 2)]
  calc
    (2:ℝ) • ((firstH X * B) * (star C * firstH X)) =
      (2:ℝ) • (firstH X * ((B * star C) * firstH X)) := by congr 1; noncomm_ring
    _ = firstH X * firstH X := by rw [hmod, hDH, mul_smul_comm, smul_smul]; norm_num

lemma firstR_orthogonal {X B C : A} (hcross : B * star C = 0) :
    star (firstR X B) * firstR X C = 0 := by
  simp only [firstR, star_smul, star_trivial, star_mul, star_star, smul_mul_smul]
  calc
    _ = (Real.sqrt 2 * Real.sqrt 2) • (star (firstH X) * (B * star C) * firstH X) := by
      congr 1; noncomm_ring
    _ = 0 := by rw [hcross, mul_zero, zero_mul, smul_zero]

end MainGap

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

lemma ramp_projection {P : A} (hP : IsStarProjection P) {l u : ℝ} (hl : 0 ≤ l)
    (hlu : l < u) (hu : u ≤ 1) : ramp P l u = P := by
  conv_rhs => rw [← cfcₙ_id ℝ P hP.isSelfAdjoint]
  apply cfcₙ_congr
  intro t ht
  rcases Set.mem_insert_iff.mp (hP.isIdempotentElem.quasispectrum_subset ℝ ht) with ht | ht
  · subst t
    exact rampFn_zero hl
  · have ht : t = 1 := Set.mem_singleton_iff.mp ht
    subst t
    exact rampFn_one hlu hu

lemma cut_projection {P : A} (hP : IsStarProjection P) {l : ℝ} (hl : 0 ≤ l) (hl1 : l ≤ 1) :
    cut P l = (1-l) • P := by
  conv_rhs => rw [← cfcₙ_id ℝ P hP.isSelfAdjoint]
  rw [← cfcₙ_smul (1-l) id P continuousOn_id rfl]
  apply cfcₙ_congr
  intro t ht
  rcases Set.mem_insert_iff.mp (hP.isIdempotentElem.quasispectrum_subset ℝ ht) with ht | ht
  · subst t
    simp [max_eq_right (neg_nonpos.mpr hl)]
  · have ht : t = 1 := Set.mem_singleton_iff.mp ht
    subst t
    simp [max_eq_left (sub_nonneg.mpr hl1)]

lemma scalingDefect_expansion {H r : A} (hH : IsSelfAdjoint H) (hnorm : ‖H‖ ≤ 1) :
    scalingDefect H r = H*H-r*star r-r*scalingComplement H-scalingComplement H*star r := by
  have hb := scalingComplement_mul_self hH hnorm
  simp only [scalingDefect, scalingIsometry, star_add, scalingComplement_selfAdjoint H |>.star_eq,
    add_mul, mul_add]
  rw [hb]
  noncomm_ring

lemma scalingDefect_compress {H K r : A} (hH : IsSelfAdjoint H) (hK : IsSelfAdjoint K)
    (hnorm : ‖H‖ ≤ 1) (hKH : K*H=H) (hHr : H*r=r) (hrK : r*K=r) :
    K * scalingDefect H r * K = scalingDefect H r := by
  have hHK : H*K=H := by
    simpa only [star_mul, hH.star_eq, hK.star_eq] using congrArg star hKH
  have hKr : K*r=r := by rw [← hHr, ← mul_assoc, hKH]
  have hsrK : star r*K=star r := by
    simpa only [star_mul, hK.star_eq, star_star] using congrArg star hKr
  have hKsr : K*star r=star r := by
    simpa only [star_mul, hK.star_eq, star_star] using congrArg star hrK
  have hcomm : Commute K H := (show K*H=H*K by rw [hKH,hHK])
  have hbcomm : Commute K (scalingComplement H) := by
    exact ((Commute.one_right K).sub_right (hcomm.mul_right hcomm)).symm.cfcₙ_nnreal NNReal.sqrt |>.symm
  have hleft : K * scalingDefect H r = scalingDefect H r := by
    rw [scalingDefect_expansion hH hnorm]
    simp only [mul_sub, ← mul_assoc, hKH, hKr]
    rw [hbcomm.eq, mul_assoc, hKsr]
  have hright : scalingDefect H r * K = scalingDefect H r := by
    simpa only [star_mul, hK.star_eq, show star (scalingDefect H r) = scalingDefect H r from
      ((IsSelfAdjoint.one A).sub (IsSelfAdjoint.mul_star_self _)).star_eq] using congrArg star hleft
  rw [hleft, hright]

end MainGap

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

theorem four_fixed_impossible {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
    (hV : firstV X ≠ 0)
    (hD : B 0 * star (B 0) ≤ (1/2 : ℝ) • (1 : A))
    (hmod : B 1 * star (B 1) = B 0 * star (B 0))
    (hcross : B 0 * star (B 1) = 0)
    (hHB₀ : firstH X * star (B 0) = star (B 0))
    (hHB₁ : firstH X * star (B 1) = star (B 1))
    (hU : firstU X (B 0) = 0)
    (hD₃ : B 2 * star (B 2) ≤ (1/2 : ℝ) • (1 : A))
    (hc₃ : star (B 2) * B 3 = 0)
    (hm₃ : star (B 2) * B 2 = star (B 3) * B 3)
    (hR : lastR X (B 0) (B 2) = 0)
    (hs₃ : ramp (prospectiveDefect X (B 0)) 0 (1/2) * B 3 = B 3) : False := by
  have hH : IsSelfAdjoint (firstH X) := .of_nonneg (ramp_nonneg X (by norm_num))
  have hK : IsSelfAdjoint (firstK X) := .of_nonneg (ramp_nonneg X (by norm_num))
  have hHnorm : ‖firstH X‖ ≤ 1 := norm_ramp_le_one _ (by norm_num)
  have hHne : firstH X ≠ 0 := by
    intro hz
    apply hV
    simpa only [hz, zero_mul] using (firstH_fixes_V hX).symm
  have hDx : (B 0 * star (B 0)) * firstX X = (1/2 : ℝ) • firstX X :=
    sandwich_zero_eigen (cut_nonneg X _) (mul_star_self_nonneg _) hD hU
  have hDH : (B 0 * star (B 0)) * firstH X = (1/2 : ℝ) • firstH X :=
    Her_eigen_left hDx (firstH_mem_firstX hX)
  have hρ₀ : star (firstR X (B 0)) * firstR X (B 0) = firstH X * firstH X :=
    firstR_inner rfl hDH
  have hρ₁ : star (firstR X (B 1)) * firstR X (B 1) = firstH X * firstH X :=
    firstR_inner rfl (hmod ▸ hDH)
  have hρc : star (firstR X (B 0)) * firstR X (B 1) = 0 := firstR_orthogonal hcross
  have hHr₀ : firstH X * firstR X (B 0) = firstR X (B 0) := by
    simp only [firstR, mul_smul_comm, ← mul_assoc, hHB₀]
  have hHr₁ : firstH X * firstR X (B 1) = firstR X (B 1) := by
    simp only [firstR, mul_smul_comm, ← mul_assoc, hHB₁]
  let P := scalingDefect (firstH X) (firstR X (B 0))
  have hP : IsStarProjection P := scalingDefect_projection hH hHnorm hHr₀ hρ₀
  have hPne : P ≠ 0 := scalingDefect_ne_zero hH hHnorm hHne hHr₁ hρc hρ₁
  have hKH : firstK X * firstH X = firstH X := firstK_fixes_H hX
  have hHK : firstH X * firstK X = firstH X := by
    simpa only [star_mul, hK.star_eq, hH.star_eq] using congrArg star hKH
  have hrK : firstR X (B 0) * firstK X = firstR X (B 0) := by
    simp only [firstR, smul_mul_assoc, mul_assoc, hHK]
  have hP₀ : prospectiveDefect X (B 0) = P := by
    change ramp (firstK X * P * firstK X) 0 1 = P
    rw [scalingDefect_compress hH hK hHnorm hKH hHr₀ hrK]
    exact ramp_projection hP (by norm_num) (by norm_num) le_rfl
  have hx' : lastX X (B 0) = (1/2 : ℝ) • P := by
    simp only [lastX, hP₀, cut_projection hP (by norm_num : (0:ℝ) ≤ 1/2)
      (by norm_num : (1/2:ℝ) ≤ 1)]
    norm_num
  have hD₃x : (B 2 * star (B 2)) * lastX X (B 0) = (1/2 : ℝ) • lastX X (B 0) :=
    sandwich_zero_eigen (lastX_nonneg X _) (mul_star_self_nonneg _) hD₃ hR
  have hD₃P : (B 2 * star (B 2)) * P = (1/2 : ℝ) • P := by
    rw [hx', mul_smul_comm, smul_comm] at hD₃x
    exact (smul_right_injective A (by norm_num : (1/2 : ℝ) ≠ 0)) hD₃x
  have hPB : P * B 3 = B 3 := by
    rw [hP₀, ramp_projection hP (by norm_num) (by norm_num) (by norm_num)] at hs₃
    exact hs₃
  exact hPne (last_pair_kills_defect (by norm_num : (1/2 : ℝ) ≠ 0) hPB hc₃ hm₃ hD₃P)

end MainGap

namespace MainGap
variable {A D : Type*} [CStarAlgebra A] [CStarAlgebra D]
local instance defectSandwichOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance defectSandwichStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance representedDefectOrder : PartialOrder D := CStarAlgebra.spectralOrder D
local instance representedDefectStarOrder : StarOrderedRing D := CStarAlgebra.spectralOrderedRing D

lemma firstSandwich_single_le {U V w : A} (hV : 0 ≤ V) (η : ℝ) {E : Finset A}
    (hw : w ∈ E) :
    (cut U η * w * CFC.sqrt V) * star (cut U η * w * CFC.sqrt V) ≤
      firstSandwich U V η E := by
  have hsum : w * V * star w ≤ ∑ v ∈ E, v * V * star v :=
    Finset.single_le_sum (fun v _ => star_right_conjugate_nonneg hV v) hw
  have h := conjugate_le_conjugate_of_nonneg hsum (cut_nonneg U η)
  have heq : (cut U η * w * CFC.sqrt V) * star (cut U η * w * CFC.sqrt V) =
      cut U η * (w * V * star w) * cut U η := by
    simp only [star_mul, IsSelfAdjoint.of_nonneg (CFC.sqrt_nonneg V) |>.star_eq,
      IsSelfAdjoint.of_nonneg (cut_nonneg U η) |>.star_eq]
    calc
      _ = cut U η * w * (CFC.sqrt V * CFC.sqrt V) * star w * cut U η := by noncomm_ring
      _ = _ := by rw [CFC.sqrt_mul_sqrt_self V hV]; noncomm_ring
  rw [heq]
  exact h

lemma represented_single_sq_le (π : A →⋆ₐ[ℂ] D) {U V w : A} (hV : 0 ≤ V)
    (η : ℝ) {E : Finset A} (hw : w ∈ E) :
    ‖π (cut U η * w * CFC.sqrt V)‖ ^ 2 ≤ ‖π (firstSandwich U V η E)‖ := by
  have h := OrderHomClass.mono π (firstSandwich_single_le (U := U) hV η hw)
  rw [map_mul, map_star] at h
  simpa only [CStarRing.norm_self_mul_star, sq] using
    CStarAlgebra.norm_le_norm_of_le_of_nonneg h (mul_star_self_nonneg _)

lemma represented_mixed_estimate (π : A →⋆ₐ[ℂ] D) {U V w : A} (hU : 0 ≤ U) (hV : 0 ≤ V)
    {η : ℝ} (hη : 0 < η) {E : Finset A} (hw : w ∈ E)
    (hD : ‖π (firstSandwich U V η E)‖ ≤ 2*η) :
    ‖π (U*w*V)‖ ≤ Real.sqrt (2*η) * ‖CFC.sqrt V‖ + η*‖w‖*‖V‖ := by
  have hr : ‖π (cut U η * w * CFC.sqrt V)‖ ≤ Real.sqrt (2*η) := by
    exact (Real.le_sqrt (norm_nonneg _) (by positivity)).mpr
      ((represented_single_sq_le π hV η hw).trans hD)
  have hsplit : U*w*V = (cut U η * w * CFC.sqrt V) * CFC.sqrt V +
      (U-cut U η)*w*V := by
    rw [mul_assoc (cut U η * w), CFC.sqrt_mul_sqrt_self V hV]
    noncomm_ring
  rw [hsplit, map_add]
  apply norm_add_le _ _ |>.trans
  apply add_le_add
  · rw [map_mul]
    exact (norm_mul_le _ _).trans (mul_le_mul hr (NonUnitalStarAlgHom.norm_apply_le π _) (norm_nonneg _) (by positivity))
  · rw [map_mul, map_mul]
    calc
      ‖(π (U-cut U η) * π w) * π V‖ ≤ ‖π (U-cut U η)‖ * ‖π w‖ * ‖π V‖ :=
        (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _))
      _ ≤ η*‖w‖*‖V‖ := mul_le_mul
        (mul_le_mul ((NonUnitalStarAlgHom.norm_apply_le π _).trans (norm_sub_cut_le hU hη.le))
          (NonUnitalStarAlgHom.norm_apply_le π w) (norm_nonneg _) hη.le)
        (NonUnitalStarAlgHom.norm_apply_le π V) (norm_nonneg _) (by positivity)

end MainGap

end

end OAI