import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.DimensionDrop.Limit
import OAI.Analysis.JiangSu.DimensionDrop.TraceExistence

namespace OAI


noncomputable section
namespace SequentialCStar
open Pureness Filter
open scoped Topology

variable {D : Type*} [CStarAlgebra D]

lemma selfAdjoint_span_star {g x : D} (hg : IsSelfAdjoint g)
    (hx : x∈TwoSidedIdeal.span {g}) : star x∈TwoSidedIdeal.span {g} := by
  induction hx using TwoSidedIdeal.span_induction with
  | mem x hx =>
    rw [Set.mem_singleton_iff.mp hx,hg.star_eq]
    exact TwoSidedIdeal.subset_span (Set.mem_singleton g)
  | zero => simp
  | add x y _ _ hx hy => simpa only [star_add] using (TwoSidedIdeal.span {g}).add_mem hx hy
  | neg x _ hx => simpa only [star_neg] using (TwoSidedIdeal.span {g}).neg_mem hx
  | left_absorb a x _ hx =>
    simpa only [star_mul] using (TwoSidedIdeal.span {g}).mul_mem_right (star x) (star a) hx
  | right_absorb a x _ hx =>
    simpa only [star_mul] using (TwoSidedIdeal.span {g}).mul_mem_left (star a) (star x) hx

def generatedClosedStarIdeal {g : D} (hg : IsSelfAdjoint g) : ClosedStarIdeal D where
  ideal := closedTwoSidedIdeal (TwoSidedIdeal.span {g})
  isClosed := by rw [coe_closedTwoSidedIdeal]; exact isClosed_closure
  star_mem := by
    intro x hx
    rw [←SetLike.mem_coe,coe_closedTwoSidedIdeal] at hx ⊢
    obtain ⟨u,hu,hux⟩ := mem_closure_iff_seq_limit.mp hx
    exact isClosed_closure.mem_of_tendsto hux.star
      (Eventually.of_forall (fun n => subset_closure (selfAdjoint_span_star hg (hu n))))

lemma generatedClosedStarIdeal_mem {g : D} (hg : IsSelfAdjoint g) :
    g∈(generatedClosedStarIdeal hg).ideal := by
  change g∈closedTwoSidedIdeal (TwoSidedIdeal.span {g})
  rw [←SetLike.mem_coe,coe_closedTwoSidedIdeal]
  exact subset_closure (TwoSidedIdeal.subset_span (Set.mem_singleton g))

lemma generatedClosedStarIdeal_le {g : D} (hg : IsSelfAdjoint g)
    (I : TwoSidedIdeal D) (hI : IsClosed (I:Set D)) (hgI : g∈I) :
    (generatedClosedStarIdeal hg).ideal≤I := by
  change closedTwoSidedIdeal (TwoSidedIdeal.span {g})≤I
  rw [TwoSidedIdeal.le_iff,coe_closedTwoSidedIdeal]
  apply closure_minimal _ hI
  exact TwoSidedIdeal.span_le.mpr (by simpa)

namespace System
variable {C : ℕ → Type*} [∀ n,CStarAlgebra (C n)] [∀ n,Nontrivial (C n)]
variable (S : System C)

def EventuallyFull : Prop := ∀ n (a : C n),a≠0 →
  ∃ (m : ℕ) (h : n≤ m),∀ I : TwoSidedIdeal (C m),S.map h a∈I → I=⊤

variable [PartialOrder S.Limit] [StarOrderedRing S.Limit]

lemma closedStarIdeal_trivial (hS : S.EventuallyFull) (J : ClosedStarIdeal S.Limit) :
    J.ideal=⊥ ∨ J.ideal=⊤ := by
  by_cases hJ : J.ideal=⊤
  · exact Or.inr hJ
  left
  let π : S.Limit →⋆ₐ[ℂ] J.Quotient :=
    { J.quotientMap with map_star' := J.quotientMap_star }
  have hker (x : S.Limit) : π x=0 ↔ x∈J.ideal := by
    change J.ideal.ringCon.mk' x=J.ideal.ringCon.mk' 0 ↔ x∈J.ideal
    exact ⟨Quotient.exact,Quotient.sound⟩
  have hπ1 : π 1≠0 := by
    intro h
    exact hJ (J.ideal.eq_top ((hker 1).mp h))
  have hinj (n : ℕ) : Function.Injective (π.comp (S.inclusion n)) := by
    apply (π.comp (S.inclusion n)).toLinearMap.ker_eq_bot.mp
    apply le_antisymm _ bot_le
    intro a ha
    change a=0
    by_contra ha0
    obtain ⟨m,hnm,hfull⟩ := hS n a ha0
    let I := TwoSidedIdeal.ker (π.comp (S.inclusion m))
    have he : S.map hnm a∈I := by
      apply (TwoSidedIdeal.mem_ker _).mpr
      change π (S.inclusion m (S.map hnm a))=0
      rw [S.inclusion_compatible]
      exact ha
    have hI := hfull I he
    have h1 : (1:C m)∈I := I.one_mem hI
    apply hπ1
    have he1 := (TwoSidedIdeal.mem_ker _).mp h1
    change π (S.inclusion m 1)=0 at he1
    simpa using he1
  have hnorm (n : ℕ) (a : C n) : ‖π (S.inclusion n a)‖=‖a‖ :=
    NonUnitalStarAlgHom.norm_map (π.comp (S.inclusion n)).toNonUnitalStarAlgHom (hinj n) a
  apply le_antisymm _ bot_le
  intro x hx
  change x=0
  apply norm_eq_zero.mp
  apply le_antisymm _ (norm_nonneg _)
  apply le_of_forall_pos_le_add
  intro ε hε
  obtain ⟨n,a,ha⟩ := S.finite_stage_approximation x (half_pos hε)
  have hπx : π x=0 := (hker x).mpr hx
  have hA : ‖a‖<ε/2 := by
    rw [←hnorm n a]
    have h := NonUnitalStarAlgHom.norm_apply_le π (S.inclusion n a-x)
    rw [map_sub,hπx,sub_zero,norm_sub_rev] at h
    exact h.trans_lt ha
  have h := norm_add_le (x-S.inclusion n a) (S.inclusion n a)
  rw [sub_add_cancel,S.inclusion_norm] at h
  linarith

theorem limit_topologicallySimple (hS : S.EventuallyFull) : TopologicallySimple S.Limit := by
  intro I hI
  by_cases h0 : I=⊥
  · exact Or.inl h0
  right
  obtain ⟨x,hx,hx0⟩ := SetLike.exists_of_lt (bot_lt_iff_ne_bot.mpr h0)
  have hxne : x≠0 := by simpa using hx0
  have hg : IsSelfAdjoint (star x*x) := IsSelfAdjoint.star_mul_self x
  let J := generatedClosedStarIdeal hg
  have hJI : J.ideal≤I := generatedClosedStarIdeal_le hg I hI (I.mul_mem_left _ _ hx)
  rcases S.closedStarIdeal_trivial hS J with hbot|htop
  · have hz := generatedClosedStarIdeal_mem hg
    change star x*x∈J.ideal at hz
    rw [hbot,TwoSidedIdeal.mem_bot] at hz
    have hn := CStarRing.norm_star_mul_self (x := x)
    rw [hz,norm_zero] at hn
    have : ‖x‖=0 := by nlinarith [norm_nonneg x]
    exact False.elim (hxne (norm_eq_zero.mp this))
  · exact top_unique (htop ▸ hJI)

end System
end SequentialCStar

end


noncomputable section
namespace OriginalJiangSu
open JiangSuConstruction
open scoped ComplexOrder CStarAlgebra

lemma system_eventuallyFull : system.EventuallyFull := by
  intro n f hf
  obtain ⟨m,h,hf'⟩ := eventually_fiberwise_nonzero n f hf
  refine ⟨m,h,?_⟩
  intro I hI
  exact dimensionDrop_full_of_fiberwise_nonzero _ hf' I hI

theorem simple : Pureness.TopologicallySimple Algebra :=
  system.limit_topologicallySimple system_eventuallyFull

end OriginalJiangSu

end

end OAI