lean/OAI/Analysis/CharacterCriterion/Fullness.lean

import OAI.Analysis.CharacterCriterion.Representations

namespace OAI

noncomputable section
open scoped TensorProduct
open scoped InnerProductSpace
open scoped BigOperators
open Set Module
open Topology
open NormedSpace
open scoped ComplexOrder
open scoped ComplexOrder
open scoped InnerProductSpace


namespace KirchbergRordam.GenericRW
namespace PrimitiveSeparation
variable {A : Type*} [CStarAlgebra A] [Nontrivial A]
variable (I : Ideal A) [I.IsTwoSided] [IsClosed (I : Set A)]

instance quotientNormedAlgebra : NormedAlgebra ℂ (A ⧸ I) where
  norm_smul_le := norm_smul_le

def quotientCLM : A →L[ℂ] (A ⧸ I) :=
  (Ideal.Quotient.mkₐ ℂ I).toLinearMap.mkContinuous 1 fun a => by
    change ‖(Submodule.Quotient.mk a : A ⧸ I)‖ ≤ 1 * ‖a‖
    simpa only [one_mul] using Submodule.Quotient.norm_mk_le I a

omit [Nontrivial A] in
@[simp] lemma quotientCLM_apply (a : A) : quotientCLM I a = Ideal.Quotient.mk I a := rfl

lemma quotient_norm_one (hI : I ≠ ⊤) : ‖(1 : A ⧸ I)‖ = 1 := by
  let _ : Nontrivial (A ⧸ I) := Ideal.Quotient.nontrivial_iff.mpr hI
  apply le_antisymm _ (one_le_norm_one (A ⧸ I))
  change ‖(Submodule.Quotient.mk (1 : A) : A ⧸ I)‖ ≤ 1
  simpa only [norm_one] using Submodule.Quotient.norm_mk_le I (1 : A)


def stateFace : Set (WeakDual ℂ A) := PureStates.normStates A ∩ {φ | ∀ a ∈ I, φ a = 0}

omit [Nontrivial A] [I.IsTwoSided] [IsClosed (I : Set A)] in
lemma stateFace_compact : IsCompact (stateFace I) :=
  (PureStates.normStates_compact A).inter_right
    (by
      simp only [Set.ofPred_forall]
      exact isClosed_iInter fun a => isClosed_iInter fun _ =>
        isClosed_eq (WeakDual.eval_continuous a) continuous_const)

lemma stateFace_nonempty (hI : I ≠ ⊤) : (stateFace I).Nonempty := by
  let _ : Nontrivial (A ⧸ I) := Ideal.Quotient.nontrivial_iff.mpr hI
  obtain ⟨f, hfn, hf1⟩ := exists_dual_vector ℂ (1 : A ⧸ I) (by rw [quotient_norm_one I hI]; exact one_ne_zero)
  have hf1 : f 1 = 1 := by simpa [quotient_norm_one I hI] using hf1
  let g := f.comp (quotientCLM I)
  have hg : ‖g‖ ≤ 1 := by
    apply g.opNorm_le_bound (by norm_num)
    intro a
    have hq : ‖quotientCLM I a‖ ≤ ‖a‖ := Submodule.Quotient.norm_mk_le I a
    change ‖f (quotientCLM I a)‖ ≤ 1 * ‖a‖
    calc
      ‖f (quotientCLM I a)‖ ≤ ‖f‖ * ‖quotientCLM I a‖ := f.le_opNorm _
      _ ≤ 1 * ‖a‖ := by rw [hfn, one_mul, one_mul]; exact hq
  refine ⟨StrongDual.toWeakDual g, ⟨hg, ?_⟩, ?_⟩
  · change f (Ideal.Quotient.mk I 1) = 1
    simpa only [map_one] using hf1
  · intro a ha
    change f (Ideal.Quotient.mk I a) = 0
    rw [Ideal.Quotient.eq_zero_iff_mem.mpr ha, map_zero]

variable [PartialOrder A] [StarOrderedRing A]

omit [I.IsTwoSided] [IsClosed (I : Set A)] in
lemma stateFace_isFace (φ ψ χ : WeakDual ℂ A) (hφ : ∀ a ∈ I, φ a = 0)
    (hψ : ψ ∈ PureStates.normStates A) (hχ : χ ∈ PureStates.normStates A)
    (s t : ℝ) (hs : 0 < s) (ht : 0 < t) (he : s • ψ + t • χ = φ) :
    (∀ a ∈ I, ψ a = 0) ∧ (∀ a ∈ I, χ a = 0) := by
  have hψp (a : A) (ha : 0 ≤ a) : 0 ≤ ψ a :=
    States.eval_nonneg ψ.toStrongDual hψ.1 hψ.2 a ha
  have hχp (a : A) (ha : 0 ≤ a) : 0 ≤ χ a :=
    States.eval_nonneg χ.toStrongDual hχ.1 hχ.2 a ha
  have hz (a : A) (ha : a ∈ I) : ψ (star a * a) = 0 ∧ χ (star a * a) = 0 := by
    have hpa := hψp (star a * a) (star_mul_self_nonneg a)
    have hca := hχp (star a * a) (star_mul_self_nonneg a)
    have he' := congrArg (fun f : WeakDual ℂ A => (f (star a * a)).re) he
    have hf := hφ (star a * a) (I.mul_mem_left _ ha)
    change ((s • ψ (star a * a) + t • χ (star a * a)) : ℂ).re = (φ (star a * a)).re at he'
    simp only [Complex.add_re, Complex.smul_re, smul_eq_mul] at he'
    rw [hf, Complex.zero_re] at he'
    have hp0 : (ψ (star a * a)).re = 0 := by
      nlinarith [(Complex.nonneg_iff.mp hpa).1, (Complex.nonneg_iff.mp hca).1]
    have hc0 : (χ (star a * a)).re = 0 := by
      nlinarith [(Complex.nonneg_iff.mp hpa).1, (Complex.nonneg_iff.mp hca).1]
    constructor <;> apply Complex.ext
    · exact hp0
    · exact (Complex.nonneg_iff.mp hpa).2.symm
    · exact hc0
    · exact (Complex.nonneg_iff.mp hca).2.symm
  constructor
  · intro a ha
    exact Representations.positive_zero_of_square_zero
      (PositiveLinearMap.mk₀ ψ.toStrongDual.toLinearMap hψp) a (hz a ha).1
  · intro a ha
    exact Representations.positive_zero_of_square_zero
      (PositiveLinearMap.mk₀ χ.toStrongDual.toLinearMap hχp) a (hz a ha).2


theorem exists_pure_annihilating (hI : I ≠ ⊤) :
    ∃ φ : A →L[ℂ] ℂ, PureStates.IsPure A φ ∧ ∀ a ∈ I, φ a = 0 := by
  obtain ⟨φ, hφ⟩ := (stateFace_compact I).extremePoints_nonempty (stateFace_nonempty I hI)
  refine ⟨φ.toStrongDual, ⟨hφ.1.1, ?_⟩, hφ.1.2⟩
  intro ψ hψ χ hχ he
  obtain ⟨s, t, hs, ht, hst, heq⟩ := he
  obtain ⟨hψI, hχI⟩ := stateFace_isFace I φ ψ χ hφ.1.2 hψ hχ s t hs ht heq
  exact hφ.2 ⟨hψ, hψI⟩ ⟨hχ, hχI⟩ ⟨s, t, hs, ht, hst, heq⟩

omit [IsClosed (I : Set A)] in
lemma pureRepresentation_annihilates (φ : A →L[ℂ] ℂ) (hp : PureStates.IsPure A φ)
    (hφ : ∀ a ∈ I, φ a = 0) (a : A) (ha : a ∈ I) :
    (Representations.pureRepresentation φ hp).representation a = 0 := by
  let f := Representations.stateOfPure φ hp
  have hv (b : A) : Representations.gnsVector f (a * b) = 0 := by
    apply (inner_self_eq_zero (𝕜 := ℂ)).mp
    rw [Representations.gnsVector_inner]
    exact hφ _ (I.mul_mem_left _ (I.mul_mem_right _ ha))
  apply ContinuousLinearMap.ext
  intro x
  have hd := Representations.gns_cyclic f
  apply hd.induction_on (p := fun x => f.gnsStarAlgHom a x = 0) x
  · exact isClosed_eq ((f.gnsStarAlgHom a).continuous) continuous_const
  · intro b
    simp only [Representations.gnsVector_apply, mul_one]
    exact hv b


theorem exists_irreducible_annihilating (hI : I ≠ ⊤) :
    ∃ ρ : IrreducibleRepresentation A, ∀ a ∈ I, ρ.representation a = 0 := by
  obtain ⟨φ, hp, hφ⟩ := exists_pure_annihilating I hI
  exact ⟨Representations.pureRepresentation φ hp,
    fun a ha => pureRepresentation_annihilates I φ hp hφ a ha⟩

end PrimitiveSeparation
end KirchbergRordam.GenericRW

namespace KirchbergRordam.GenericRW.Fullness
variable {A : Type*} [CStarAlgebra A]


def closedIdeal (I : TwoSidedIdeal A) : Ideal A := I.asIdeal.topologicalClosure

instance closedIdeal_twoSided (I : TwoSidedIdeal A) : (closedIdeal I).IsTwoSided where
  mul_mem_of_left := by
    intro a b ha
    exact (show Set.MapsTo (fun x : A => x * b) (I : Set A) (I : Set A) from
      fun x hx => I.mul_mem_right x b hx).closure (continuous_mul_const b) ha

instance closedIdeal_isClosed (I : TwoSidedIdeal A) : IsClosed (closedIdeal I : Set A) :=
  isClosed_closure

lemma eq_top_of_closedIdeal_eq_top (I : TwoSidedIdeal A) (hI : closedIdeal I = ⊤) : I = ⊤ := by
  have h1 : (1 : A) ∈ closure (I : Set A) := by
    change (1 : A) ∈ closedIdeal I
    rw [hI]
    trivial
  obtain ⟨x, hx, hnear⟩ := Metric.mem_closure_iff.mp h1 1 zero_lt_one
  have hu : IsUnit x := by
    have hnorm : ‖1 - x‖ < 1 := by simpa only [dist_eq_norm] using hnear
    simpa only [sub_sub_cancel] using isUnit_one_sub_of_norm_lt_one hnorm
  have ht := I.asIdeal.eq_top_of_isUnit_mem hx hu
  apply le_antisymm le_top
  intro x _
  change x ∈ I.asIdeal
  rw [ht]
  trivial


def IsFull (a : A) : Prop := TwoSidedIdeal.span {a} = ⊤

lemma full_iff_closed (a : A) : IsFull a ↔ closedIdeal (TwoSidedIdeal.span {a}) = ⊤ := by
  constructor
  · intro h
    apply top_unique
    intro x hx
    apply subset_closure
    rw [show TwoSidedIdeal.span {a} = ⊤ from h]
    trivial
  · exact eq_top_of_closedIdeal_eq_top _

lemma full_of_survives [Nontrivial A]
    (a : A) (h : ∀ π : IrreducibleRepresentation A, π.representation a ≠ 0) : IsFull a := by
  let := CStarAlgebra.spectralOrder A
  let := CStarAlgebra.spectralOrderedRing A
  apply (full_iff_closed a).mpr
  by_contra hn
  obtain ⟨π, hπ⟩ := PrimitiveSeparation.exists_irreducible_annihilating
    (closedIdeal (TwoSidedIdeal.span {a})) hn
  exact h π (hπ a (subset_closure (TwoSidedIdeal.subset_span rfl)))

lemma full_ne_zero [Nontrivial A] {a : A} (ha : IsFull a) : a ≠ 0 := by
  intro he
  subst a
  have h : (1 : A) ∈ TwoSidedIdeal.span {0} := by
    rw [show TwoSidedIdeal.span {(0 : A)} = ⊤ from ha]
    exact TwoSidedIdeal.mem_top A
  have hh : TwoSidedIdeal.span ({0} : Set A) ≤ ⊥ := TwoSidedIdeal.span_le.mpr (by simp)
  exact one_ne_zero ((TwoSidedIdeal.mem_bot _).mp (hh h))

lemma full_survives {B : Type*} [CStarAlgebra B] [Nontrivial B]
    {a : A} (ha : IsFull a) (φ : A →⋆ₐ[ℂ] B) : φ a ≠ 0 := by
  intro hz
  have hk : TwoSidedIdeal.span {a} ≤ TwoSidedIdeal.ker φ.toRingHom :=
    TwoSidedIdeal.span_le.mpr (Set.singleton_subset_iff.mpr ((TwoSidedIdeal.mem_ker _).mpr hz))
  have h1 : (1 : A) ∈ TwoSidedIdeal.span {a} := by
    rw [show TwoSidedIdeal.span {a} = ⊤ from ha]
    exact TwoSidedIdeal.mem_top A
  have hz1 := (TwoSidedIdeal.mem_ker _).mp (hk h1)
  exact one_ne_zero (by simpa only [map_one] using hz1)

lemma bridges_span_one {a b : A} (ha : IsFull a) (hb : IsFull b) :
    TwoSidedIdeal.span (Set.range (fun d : A => a * d * b)) = ⊤ := by
  let J := TwoSidedIdeal.span (Set.range (fun d : A => a * d * b))
  have hmul {x : A} (hx : x ∈ TwoSidedIdeal.span {a}) : ∀ d : A, x * d * b ∈ J := by
    induction hx using TwoSidedIdeal.span_induction with
    | mem x hx => subst x; intro d; exact TwoSidedIdeal.subset_span ⟨d, rfl⟩
    | zero => intro d; simp only [zero_mul]; exact J.zero_mem
    | add x y hx hy ihx ihy =>
      intro d
      simpa only [add_mul] using J.add_mem (ihx d) (ihy d)
    | neg x hx ih =>
      intro d
      simpa only [neg_mul] using J.neg_mem (ih d)
    | left_absorb c x hx ih =>
      intro d
      simpa only [mul_assoc] using J.mul_mem_left c _ (ih d)
    | right_absorb c x hx ih =>
      intro d
      simpa only [mul_assoc] using ih (c * d)
  have h1 : (1 : A) ∈ TwoSidedIdeal.span {a} := by
    rw [show TwoSidedIdeal.span {a} = ⊤ from ha]
    exact TwoSidedIdeal.mem_top A
  have hbJ : b ∈ J := by simpa using hmul h1 1
  have hk : TwoSidedIdeal.span {b} ≤ J := TwoSidedIdeal.span_le.mpr (by simpa)
  apply top_unique
  rwa [hb] at hk

lemma mem_span_finite {s : Set A} {x : A} (hx : x ∈ TwoSidedIdeal.span s) :
    ∃ t : Finset A, ↑t ⊆ s ∧ x ∈ TwoSidedIdeal.span (t : Set A) := by
  classical
  induction hx using TwoSidedIdeal.span_induction with
  | mem x hx => exact ⟨{x}, by simpa, TwoSidedIdeal.subset_span (by simp)⟩
  | zero => exact ⟨∅, by simp, TwoSidedIdeal.zero_mem _⟩
  | add x y hx hy ihx ihy =>
    obtain ⟨t, ht, hxt⟩ := ihx
    obtain ⟨u, hu, hyu⟩ := ihy
    refine ⟨t ∪ u, ?_, TwoSidedIdeal.add_mem _ ?_ ?_⟩
    · simpa using Set.union_subset ht hu
    · exact TwoSidedIdeal.span_mono (by simp) hxt
    · exact TwoSidedIdeal.span_mono (by simp) hyu
  | neg x hx ih =>
    obtain ⟨t, ht, hx⟩ := ih
    exact ⟨t, ht, TwoSidedIdeal.neg_mem _ hx⟩
  | left_absorb a x hx ih =>
    obtain ⟨t, ht, hx⟩ := ih
    exact ⟨t, ht, TwoSidedIdeal.mul_mem_left _ _ _ hx⟩
  | right_absorb b x hx ih =>
    obtain ⟨t, ht, hx⟩ := ih
    exact ⟨t, ht, TwoSidedIdeal.mul_mem_right _ _ _ hx⟩

end KirchbergRordam.GenericRW.Fullness
end

end OAI