lean/OAI/Analysis/CStarAlgebra/PureInfiniteness/Avoidance.lean

import OAI.Analysis.CStarAlgebra.PureInfiniteness.Ultrafilter

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap
open Filter
open scoped Topology
universe u v
variable {ι : Type*} {A : Type u} [CStarAlgebra A]
local instance avoidanceLimitPartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance avoidanceLimitStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance avoidanceLimitOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
local instance avoidanceLimitOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _
variable {H : ι → Type v} [∀ i, NormedAddCommGroup (H i)]
  [∀ i, InnerProductSpace ℂ (H i)] [∀ i, CompleteSpace (H i)]

theorem four_limit_impossible (ω : Ultrafilter ι)
    (π : ∀ i, A →⋆ₐ[ℂ] (H i →L[ℂ] H i)) (ξ : ∀ i, H i) (hξ : ∀ i, ‖ξ i‖ ≤ 1)
    {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
    (hV : ∀ᶠ i in (ω : Filter ι), (1/8 : ℝ) ≤ ‖π i (firstV X) (ξ i)‖)
    (hD₁ : ∀ i, π i (B 0) * star (π i (B 0)) ≤ (1/2 : ℝ) • 1)
    (hm₁ : ∀ i, π i (B 1 * star (B 1)) = π i (B 0 * star (B 0)))
    (hc₁ : ∀ i, π i (B 0 * star (B 1)) = 0)
    (hs₀ : ∀ i, π i (firstH X * star (B 0)) = π i (star (B 0)))
    (hs₁ : ∀ i, π i (firstH X * star (B 1)) = π i (star (B 1)))
    (hU : ∀ w : A, Tendsto (fun i => ‖π i (firstU X (B 0) * w * firstV X)‖)
      (ω : Filter ι) (𝓝 0))
    (hD₃ : ∀ i, π i (B 2) * star (π i (B 2)) ≤ (1/2 : ℝ) • 1)
    (hc₃ : ∀ i, π i (star (B 2) * B 3) = 0)
    (hm₃ : ∀ i, π i (star (B 2) * B 2) = π i (star (B 3) * B 3))
    (hR : Tendsto (fun i => ‖π i (lastR X (B 0) (B 2))‖) (ω : Filter ι) (𝓝 0))
    (hs₃ : ∀ i, π i (ramp (prospectiveDefect X (B 0)) 0 (1/2) * B 3) = π i (B 3)) : False := by
  let ρ := limitRep ω π ξ hξ
  let Ψ := rangeRestriction ρ (firstV X)
  have hkill : ∀ a : A, Tendsto (fun i => ‖π i a‖) (ω : Filter ι) (𝓝 0) → Ψ a = 0 := by
    intro a ha
    have hz : ρ a = 0 := limitRep_annihilates ω π ξ hξ a ha
    ext x
    change (ρ a x : LimitHilbert ω π ξ hξ) = 0
    rw [hz, zero_apply]
  have hzero : ∀ a : A, (∀ i, π i a = 0) → Ψ a = 0 := by
    intro a ha
    apply hkill a
    simp only [ha, norm_zero]
    exact tendsto_const_nhds
  have heq : ∀ a b : A, (∀ i, π i a = π i b) → Ψ a = Ψ b := by
    intro a b hab
    have hz := hzero (a-b) (fun i => by rw [map_sub, hab i, sub_self])
    exact sub_eq_zero.mp (by simpa only [map_sub] using hz)
  have hbound (j : Fin 4) (hj : ∀ i, π i (B j) * star (π i (B j)) ≤ (1/2 : ℝ) • 1) := by
    have hz := hzero (cut (B j * star (B j)) (1/2)) (fun i => by
      rw [map_cut_sa (π i) (.mul_star_self _) (by norm_num), map_mul, map_star]
      exact cut_zero_of_le (mul_star_self_nonneg _) (by norm_num) (hj i))
    rw [map_cut_sa (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (IsSelfAdjoint.mul_star_self (B j)) (by norm_num : (0:ℝ) ≤ 1/2), map_mul, map_star] at hz
    exact le_of_cut_zero (mul_star_self_nonneg _) (by norm_num) hz
  have hψV : firstV (Ψ X) ≠ 0 := by
    rw [← map_firstV (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)]
    exact rangeRestriction_nonzero ρ (firstV X) (.of_nonneg (cut_nonneg X _))
      (limitRep_nonzero ω π ξ hξ (firstV X) (by norm_num : (0:ℝ) < 1/8) hV)
  have hψU : firstU (Ψ X) (Ψ (B 0)) = 0 := by
    rw [← map_firstU (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)]
    apply rangeRestriction_kills ρ (firstV X) (firstU X (B 0))
    intro w
    simpa only [map_mul] using limitRep_annihilates ω π ξ hξ _ (hU w)
  apply four_fixed_impossible (map_nonneg Ψ hX) (fun i => Ψ (B i)) hψV
    (hbound 0 hD₁) ?_ ?_ ?_ ?_ hψU (hbound 2 hD₃) ?_ ?_ ?_ ?_
  · simpa only [map_mul, map_star] using heq _ _ hm₁
  · simpa only [map_mul, map_star] using hzero _ hc₁
  · simpa only [map_mul, map_star, map_firstH (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using heq _ _ hs₀
  · simpa only [map_mul, map_star, map_firstH (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using heq _ _ hs₁
  · simpa only [map_mul, map_star] using hzero _ hc₃
  · simpa only [map_mul, map_star] using heq _ _ hm₃
  · simpa only [map_lastR (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using hkill _ hR
  · have hp : IsSelfAdjoint (prospectiveDefect X (B 0)) :=
      .of_nonneg (prospectiveDefect_nonneg X _)
    simpa only [map_mul, map_ramp_sa (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ hp le_rfl, map_prospectiveDefect (D := generatedRange ρ (firstV X) →L[ℂ] generatedRange ρ (firstV X)) Ψ (.of_nonneg hX)] using
      heq _ _ hs₃

end MainGap

namespace MainGap
universe u v
open Filter
open scoped Topology
variable (A : Type u) [CStarAlgebra A]

structure HilbertRep where
  H : Type v
  [normed : NormedAddCommGroup H]
  [inner : InnerProductSpace ℂ H]
  [complete : CompleteSpace H]
  hom : A →⋆ₐ[ℂ] (H →L[ℂ] H)

attribute [instance] HilbertRep.normed HilbertRep.inner HilbertRep.complete

variable {A}
local instance avoidancePartialOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance avoidanceStarOrderedRing : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance avoidanceOperatorPartialOrder (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    PartialOrder (J →L[ℂ] J) := CStarAlgebra.spectralOrder _
local instance avoidanceOperatorStarOrderedRing (J : Type*) [NormedAddCommGroup J]
    [InnerProductSpace ℂ J] [CompleteSpace J] :
    StarOrderedRing (J →L[ℂ] J) := CStarAlgebra.spectralOrderedRing _

theorem four_avoidance_unital {X : A} (hX : 0 ≤ X) (B : Fin 4 → A)
    (hp : ∀ z : A, 0 ≤ z → z ∈ fourHer X → ProperlyInfinite z) :
    ∃ T : Fin 4 → A, (∀ j, ‖T j‖ ≤ 1) ∧ (∀ j, T j ∈ fourHer X) ∧
      ∀ R : HilbertRep.{u,v} A, (1/4 : ℝ) < ‖R.hom X‖ →
        ¬ ∀ j, R.hom (T j) = R.hom (B j) := by
  classical
  by_contra! hbad
  let F : ∀ i : FourIndex A, FourChoice.{v,u} X B i.2 (fourEta A i) :=
    fun i => Classical.choice (fourChoice_nonempty hX B hp i.2 (fourEta_pos A i))
  have hbad' : ∀ i : FourIndex A, ∃ R : HilbertRep.{u,v} A,
      (1/4 : ℝ) < ‖R.hom X‖ ∧ ∀ j, R.hom ((F i).T j) = R.hom (B j) :=
    fun i => hbad (F i).T (F i).contractive (F i).mem
  choose R hRX hmatch using hbad'
  let π := fun i => (R i).hom
  change ∀ i j, π i ((F i).T j) = π i (B j) at hmatch
  have hVbig : ∀ i, (1/8 : ℝ) < ‖π i (firstV X)‖ := by
    intro i
    have hn : ‖π i X - π i (firstV X)‖ ≤ (1/8 : ℝ) := by
      rw [← map_sub]
      exact (NonUnitalStarAlgHom.norm_apply_le (π i) _).trans
        (norm_sub_cut_le hX (by norm_num))
    have hm := norm_sub_norm_le (π i X) (π i (firstV X))
    have hi := hRX i
    change (1/4 : ℝ) < ‖π i X‖ at hi
    linarith
  choose ξ hξ hξV using fun i => (π i (firstV X)).exists_lt_apply_of_lt_opNorm (hVbig i)
  have hnξ : ∀ i, ‖ξ i‖ ≤ 1 := fun i => (hξ i).le
  have hEt := fourEta_ultra A
  apply four_limit_impossible (fourUltra A) π ξ hnξ hX B
    (Filter.Eventually.of_forall (fun i => (hξV i).le))
    (fun i => (F i).first_bound (π i) hX (fourEta_pos A i) (hmatch i)) ?_ ?_ ?_ ?_ ?_
    (fun i => (F i).last_bound (π i) hX (fourEta_pos A i) (hmatch i)) ?_ ?_ ?_ ?_
  · intro i
    have hm := congrArg (π i) (F i).first_equal
    simpa only [map_mul, map_star, hmatch i] using hm
  · intro i
    have hm := congrArg (π i) (F i).first_cross
    simpa only [map_mul, map_star, hmatch i, map_zero] using hm
  · intro i
    have hm := congrArg (π i) ((F i).first_support₀ hX)
    simpa only [map_mul, map_star, hmatch i] using hm
  · intro i
    have hm := congrArg (π i) ((F i).first_support₁ hX)
    simpa only [map_mul, map_star, hmatch i] using hm
  · intro w
    have hg : Tendsto (fun i : FourIndex A =>
        Real.sqrt (2 * fourEta A i) * ‖CFC.sqrt (firstV X)‖ +
          fourEta A i * ‖w‖ * ‖firstV X‖) (fourUltra A : Filter (FourIndex A)) (𝓝 0) := by
      convert ((hEt.const_mul 2).sqrt.mul_const ‖CFC.sqrt (firstV X)‖).add
        ((hEt.mul_const ‖w‖).mul_const ‖firstV X‖) using 1; norm_num
    apply squeeze_zero' (Filter.Eventually.of_forall (fun i => norm_nonneg _)) ?_ hg
    filter_upwards [fourUltra_le A (fourIndex_eventually_mem A w)] with i hi
    exact represented_mixed_estimate (π i) (firstU_nonneg _ _) (cut_nonneg X _)
      (fourEta_pos A i) hi ((F i).first_norm (π i) hX (fourEta_pos A i) (hmatch i)).le
  · intro i
    have hm := congrArg (π i) (F i).last_cross
    simpa only [map_mul, map_star, hmatch i, map_zero] using hm
  · intro i
    have hm := congrArg (π i) (F i).last_equal
    simpa only [map_mul, map_star, hmatch i] using hm
  · have ht : Tendsto (fun i : FourIndex A => 4 * fourEta A i)
        (fourUltra A : Filter (FourIndex A)) (𝓝 0) := by
      simpa using hEt.const_mul 4
    exact squeeze_zero' (Filter.Eventually.of_forall (fun i => norm_nonneg _))
      (Filter.Eventually.of_forall (fun i =>
        ((F i).last_norm_lt (π i) hX (fourEta_pos A i) (hmatch i)).le)) ht
  · intro i
    have hm := congrArg (π i) (F i).last_support
    simpa only [map_mul, hmatch i] using hm

end MainGap

end

end OAI