import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.TensorProducts.FaithfulTensorCrossNorm
import OAI.Analysis.JiangSu.DimensionDrop.SequentialCStarInductiveLimit

namespace OAI


noncomputable section
open scoped TensorProduct CStarAlgebra

namespace Pureness.CStarAlgebraNorm
variable {R S : Type*} [Ring R] [StarRing R] [Algebra ℂ R]
  [Ring S] [StarRing S] [Algebra ℂ S]
def comapInjective (p : Pureness.CStarAlgebraNorm S) (e : R →⋆ₐ[ℂ] S)
    (he : Function.Injective e) : Pureness.CStarAlgebraNorm R where
  toFun x := p.toAlgebraNorm (e x)
  map_zero' := by simp
  add_le' x y := by rw [map_add]; exact map_add_le_add p.toAlgebraNorm (e x) (e y)
  neg' x := by simp
  mul_le' x y := by rw [map_mul]; exact map_mul_le_mul p.toAlgebraNorm (e x) (e y)
  eq_zero_of_map_eq_zero' x hx := he (by simpa using p.toAlgebraNorm.eq_zero_of_map_eq_zero' (e x) hx)
  smul' c x := by simp [map_smul_eq_mul]
  cstar x := by
    change p.toAlgebraNorm (e (star x*x))=p.toAlgebraNorm (e x)*p.toAlgebraNorm (e x)
    rw [map_mul,map_star]
    exact p.cstar (e x)
end Pureness.CStarAlgebraNorm

namespace SequentialCStar
open Pureness

universe u v
variable {A D : Type*} [CStarAlgebra A] [CStarAlgebra D]
variable (B : Type v) [CStarAlgebra B]

def leftStarTensor (f : A →⋆ₐ[ℂ] D) : A ⊗[ℂ] B →⋆ₐ[ℂ] D ⊗[ℂ] B :=
  { Algebra.TensorProduct.map f.toAlgHom (AlgHom.id ℂ B) with
    map_star' := by
      intro z
      change (Algebra.TensorProduct.map f.toAlgHom (AlgHom.id ℂ B)) (star z)=
        star ((Algebra.TensorProduct.map f.toAlgHom (AlgHom.id ℂ B)) z)
      induction z using TensorProduct.inductionOn with
      | tmul a b => simp only [TensorProduct.star_tmul,Algebra.TensorProduct.map_tmul,
          StarAlgHom.coe_toAlgHom,map_star,AlgHom.id_apply]
      | add x y hx hy => simp only [star_add,map_add,hx,hy] }

@[simp] lemma leftStarTensor_tmul (f : A →⋆ₐ[ℂ] D) (a : A) (b : B) :
    leftStarTensor B f (a ⊗ₜ[ℂ] b)=f a ⊗ₜ[ℂ] b := rfl

lemma leftStarTensor_injective (f : A →⋆ₐ[ℂ] D) (hf : Function.Injective f) :
    Function.Injective (leftStarTensor B f) :=
  Module.Flat.rTensor_preserves_injective_linearMap f.toLinearMap hf

lemma norm_tensor_sum_le (r : CStarAlgebraNorm (A ⊗[ℂ] B))
    {I : Type*} [Fintype I] (a : I → A) (b : I → B) :
    r.toAlgebraNorm (∑ i,a i ⊗ₜ[ℂ] b i)≤∑ i,‖a i‖*‖b i‖ := by
  rw [←r.completionMap_norm,map_sum]
  apply (norm_sum_le _ _).trans
  apply Finset.sum_le_sum
  intro i _
  rw [r.completionMap_norm,NuclearUnitization.cstar_norm_tmul]

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

lemma finite_family_common_stage {I : Type*} [Fintype I] (x : I → S.Limit)
    {ε : ℝ} (hε : 0<ε) :
    ∃ (n : ℕ) (a : I → C n),∀ i,‖x i-S.inclusion n (a i)‖<ε := by
  classical
  choose n a ha using fun i => S.finite_stage_approximation (x i) hε
  let N := Finset.univ.sup n
  have hN (i : I) : n i≤N := Finset.le_sup (f:=n) (Finset.mem_univ i)
  refine ⟨N,fun i => S.map (hN i) (a i),?_⟩
  intro i
  rw [S.inclusion_compatible]
  exact ha i

lemma nuclear_norm_eq_sum (hnuc : ∀ n,IsNuclear.{u,v} (C n))
    (r s : CStarAlgebraNorm (S.Limit ⊗[ℂ] B))
    {I : Type*} [Fintype I] (x : I → S.Limit) (b : I → B) :
    r.toAlgebraNorm (∑ i,x i ⊗ₜ[ℂ] b i)=s.toAlgebraNorm (∑ i,x i ⊗ₜ[ℂ] b i) := by
  classical
  suffices h : ∀ (p q : CStarAlgebraNorm (S.Limit ⊗[ℂ] B)),
      p.toAlgebraNorm (∑ i,x i ⊗ₜ[ℂ] b i)≤q.toAlgebraNorm (∑ i,x i ⊗ₜ[ℂ] b i) by
    exact le_antisymm (h r s) (h s r)
  intro p q
  apply le_of_forall_pos_le_add
  intro ε hε
  let δ := ε/(2*(1+∑ i,‖b i‖))
  have hsum : 0≤∑ i,‖b i‖ := Finset.sum_nonneg (fun i _ => norm_nonneg _)
  have hd : 0<2*(1+∑ i,‖b i‖) := by positivity
  obtain ⟨n,a,ha⟩ := S.finite_family_common_stage x (div_pos hε hd : 0<δ)
  let z := ∑ i,x i ⊗ₜ[ℂ] b i
  let w := ∑ i,S.inclusion n (a i) ⊗ₜ[ℂ] b i
  have heq : p.toAlgebraNorm w=q.toAlgebraNorm w := by
    let e := leftStarTensor B (S.inclusion n)
    have he := leftStarTensor_injective B (S.inclusion n) (S.inclusion_isometry n).injective
    have h := (hnuc n B).elim (p.comapInjective e he) (q.comapInjective e he)
    have h' := congrArg (fun t : CStarAlgebraNorm (C n ⊗[ℂ] B) =>
      t.toAlgebraNorm (∑ i,a i ⊗ₜ[ℂ] b i)) h
    change p.toAlgebraNorm (e (∑ i,a i ⊗ₜ[ℂ] b i))=q.toAlgebraNorm (e (∑ i,a i ⊗ₜ[ℂ] b i)) at h'
    simpa only [e,map_sum,leftStarTensor_tmul] using h'
  have herr (t : CStarAlgebraNorm (S.Limit ⊗[ℂ] B)) : t.toAlgebraNorm (z-w)≤ε/2 := by
    have he : z-w=∑ i,(x i-S.inclusion n (a i)) ⊗ₜ[ℂ] b i := by
      simp only [z,w,TensorProduct.sub_tmul,Finset.sum_sub_distrib]
    rw [he]
    calc
      _ ≤ ∑ i,‖x i-S.inclusion n (a i)‖*‖b i‖ := norm_tensor_sum_le B t _ b
      _ ≤ ∑ i,δ*‖b i‖ := by gcongr with i; exact (ha i).le
      _ = δ*(∑ i,‖b i‖) := by rw [Finset.mul_sum]
      _ ≤ ε/2 := by
        dsimp [δ]
        rw [div_mul_eq_mul_div]
        apply (div_le_iff₀ hd).mpr
        nlinarith
  have h1 : p.toAlgebraNorm z≤p.toAlgebraNorm (z-w)+p.toAlgebraNorm w := by
    simpa only [sub_add_cancel] using map_add_le_add p.toAlgebraNorm (z-w) w
  have h2 : q.toAlgebraNorm w≤q.toAlgebraNorm (z-w)+q.toAlgebraNorm z := by
    have hh := map_add_le_add q.toAlgebraNorm (w-z) z
    simpa only [sub_add_cancel,map_sub_rev q.toAlgebraNorm] using hh
  have hp := herr p
  have hq := herr q
  change p.toAlgebraNorm z≤q.toAlgebraNorm z+ε
  linarith

theorem nuclear (hnuc : ∀ n,IsNuclear.{u,v} (C n)) : IsNuclear.{u,v} S.Limit := by
  intro B _
  refine ⟨fun r s => ?_⟩
  have he : r.toAlgebraNorm=s.toAlgebraNorm := by
    apply AlgebraNorm.ext
    intro z
    obtain ⟨n,x,b,rfl⟩ := TensorProduct.exists_sum_tmul_eq z
    exact S.nuclear_norm_eq_sum B hnuc r s x b
  cases r; cases s; cases he; rfl

end System
end SequentialCStar

end


namespace JiangSuConstruction

def multiplicitiesOfLarge {p q : ℕ} (hp : 0<p) (hq : 0<q) (k l : ℕ)
    (hk : 8*q≤k) (hl : 8*p≤l) : Multiplicities p q := by
  let g := l/(4*p)
  let d := k/(4*q)
  let L := (p*k)*g
  let U := (q*l)*d
  let R := k*l-L-U
  have hkp : 0<k := by omega
  have hlp : 0<l := by omega
  have hgp : 0<g := Nat.div_pos (by omega) (by positivity)
  have hdp : 0<d := Nat.div_pos (by omega) (by positivity)
  have hg : (4*p)*g≤l := Nat.mul_div_le l (4*p)
  have hd : (4*q)*d≤k := Nat.mul_div_le k (4*q)
  have hg' : l<(4*p)*(g+1) := Nat.lt_mul_div_succ l (by positivity : 0<4*p)
  have hd' : k<(4*q)*(d+1) := Nat.lt_mul_div_succ k (by positivity : 0<4*q)
  have hg8 : l≤8*(p*g) := by nlinarith
  have hd8 : k≤8*(q*d) := by nlinarith
  have hL : 4*L≤k*l := by
    calc
      4*L=k*((4*p)*g) := by dsimp [L]; ring
      _≤k*l := Nat.mul_le_mul_left k hg
  have hU : 4*U≤k*l := by
    calc
      4*U=l*((4*q)*d) := by dsimp [U]; ring
      _≤k*l := by simpa only [Nat.mul_comm] using Nat.mul_le_mul_left l hd
  have hsum : L+U≤k*l := by omega
  have htotal : L+U+R=k*l := by dsimp [R]; omega
  have hRp : 0<R := by have hr : 0<k*l := Nat.mul_pos hkp hlp; omega
  have hpg : p*g≤l := by nlinarith
  have hqd : q*d≤k := by nlinarith
  refine ⟨k,l,L,U,R,g,d,hkp,hlp,hgp,hdp,hRp,rfl,rfl,htotal,?_,?_,?_,?_,?_,?_⟩
  · rw [Nat.mul_sub_left_distrib]
    have he : U=l*(q*d) := by dsimp [U]; ring
    have hr : k*l=l*k := Nat.mul_comm k l
    omega
  · rw [Nat.mul_sub_left_distrib]
    have he : L=k*(p*g) := by dsimp [L]; ring
    omega
  · rw [Nat.mul_sub_left_distrib]
    have he : p*(q*d)=(p*q)*d := by ring
    have hc := Nat.mul_le_mul_left p hqd
    omega
  · rw [Nat.mul_sub_left_distrib]
    have he : q*(p*g)=(p*q)*g := by ring
    have hc := Nat.mul_le_mul_left q hpg
    omega
  · calc
      k*l≤k*(8*(p*g)) := Nat.mul_le_mul_left k hg8
      _=8*L := by dsimp [L]; ring
  · calc
      k*l≤l*(8*(q*d)) := by simpa only [Nat.mul_comm] using Nat.mul_le_mul_left l hd8
      _=8*U := by dsimp [U]; ring

def canonicalMultiplicities {p q : ℕ} (hp : 0<p) (hq : 0<q) : Multiplicities p q :=
  multiplicitiesOfLarge hp hq (2^(8*q)) (3^(8*p))
    (Nat.lt_two_pow_self (n := 8*q)).le
    (Nat.lt_pow_self (n := 8*p) (by decide : 1<3)).le

end JiangSuConstruction

end OAI