import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.CuntzSemigroup.CuntzRescaling
import OAI.Analysis.JiangSu.Nonunital.Regularization
import OAI.Analysis.JiangSu.CStarAlgebras.FiniteSpectralMatching

namespace OAI

noncomputable section


namespace JiangSuConstruction
open scoped CStarAlgebra ComplexOrder Kronecker
open FiniteSpectralMatching

variable {n : ℕ} {ι : Type*} [Fintype ι] [DecidableEq ι]

 theorem interval_matching_of_cumulative (x y : Fin n → Interval) (δ : ℝ)
    (hxy : ∀ t : ℝ,(Finset.univ.filter fun i => (x i:ℝ)≤t).card≤
      (Finset.univ.filter fun i => (y i:ℝ)≤t+δ).card)
    (hyx : ∀ t : ℝ,(Finset.univ.filter fun i => (y i:ℝ)≤t).card≤
      (Finset.univ.filter fun i => (x i:ℝ)≤t+δ).card) :
    ∃ e : Equiv.Perm (Fin n),∀ i,dist (x i) (y (e i))≤δ := by
  obtain ⟨e,he⟩ := permutation_of_cumulative_counts (fun i=>(x i:ℝ)) (fun i=>(y i:ℝ)) δ hxy hyx
  exact ⟨e,he⟩

 theorem pointwise_unitary_matching (x y : Fin n → Interval) (δ : ℝ)
    (hxy : ∀ t : ℝ,(Finset.univ.filter fun i => (x i:ℝ)≤t).card≤
      (Finset.univ.filter fun i => (y i:ℝ)≤t+δ).card)
    (hyx : ∀ t : ℝ,(Finset.univ.filter fun i => (y i:ℝ)≤t).card≤
      (Finset.univ.filter fun i => (x i:ℝ)≤t+δ).card) :
    ∃ u : unitary (CStarMatrix (ι×Fin n) (ι×Fin n) ℂ),
      ∀ (f : Interval → CStarMatrix ι ι ℂ) (η : ℝ),0≤η →
        (∀ s t,dist s t≤δ → ‖f s-f t‖≤η) →
        ‖unitaryConjugation u (blockDiagonalHom (fun i=>f (x i)))-
          blockDiagonalHom (fun i=>f (y i))‖≤η := by
  obtain ⟨e,he⟩ := interval_matching_of_cumulative x y δ hxy hyx
  refine ⟨permutationUnitary (Equiv.prodCongr (Equiv.refl ι) e),?_⟩
  intro f η hη hf
  rw [permutationUnitary_conjugation,reindex_blockDiagonal,←map_sub]
  apply (NonUnitalStarAlgHom.norm_apply_le
    (blockDiagonalHom : (Fin n → CStarMatrix ι ι ℂ) →⋆ₐ[ℂ]
      CStarMatrix (ι×Fin n) (ι×Fin n) ℂ) _).trans
  apply (pi_norm_le_iff_of_nonneg hη).mpr
  intro i
  apply hf
  simpa only [Equiv.apply_symm_apply] using he (e.symm i)

 theorem finite_matrix_tensor_flip (a : CStarMatrix ι ι ℂ) :
    unitaryConjugation (permutationUnitary (Equiv.prodComm ι ι))
      (CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix ι ι ℂ)))=
      CStarMatrix.ofMatrix ((1 : Matrix ι ι ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm a) := by
  rw [permutationUnitary_conjugation]
  ext ⟨i,j⟩ ⟨k,l⟩
  change a j l*(1 : Matrix ι ι ℂ) i k=(1 : Matrix ι ι ℂ) i k*a j l
  exact mul_comm _ _

end JiangSuConstruction


namespace JiangSuConstruction
open scoped CStarAlgebra ComplexOrder Kronecker

lemma conjugation_near_commuting {A : Type*} [CStarAlgebra A]
    (u : unitary A) (a b : A) (hb : Commute (u:A) b) :
    ‖unitaryConjugation u a-a‖≤2*‖a-b‖ := by
  have he : unitaryConjugation u b=b := by
    change (u:A)*b*star (u:A)=b
    rw [hb.eq,mul_assoc,u.2.2,mul_one]
  have hd : ‖unitaryConjugation u a-unitaryConjugation u b‖≤‖a-b‖ := by
    rw [←map_sub]
    exact NonUnitalStarAlgHom.norm_apply_le (unitaryConjugation u) (a-b)
  have ht := norm_sub_le_norm_sub_add_norm_sub (unitaryConjugation u a) b a
  rw [he] at hd
  rw [norm_sub_rev b a] at ht
  calc
    ‖unitaryConjugation u a-a‖ ≤ ‖unitaryConjugation u a-b‖ + ‖a-b‖ := ht
    _ ≤ ‖a-b‖ + ‖a-b‖ := add_le_add hd le_rfl
    _ = 2 * ‖a-b‖ := (two_mul _).symm

lemma amplification_commute (p n : ℕ) (a : Mat p) (b : Mat n) :
    Commute (rightAmplification p n b) (leftAmplification p n a) := by
  change ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm b) *
    (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix (Fin n) (Fin n) ℂ)) =
    (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix (Fin n) (Fin n) ℂ)) *
    ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm b)
  rw [←Matrix.mul_kronecker_mul,←Matrix.mul_kronecker_mul]
  simp only [one_mul,mul_one]

lemma blockDiagonal_constant (p n : ℕ) (a : Mat p) :
    blockDiagonalHom (fun _ : Fin n => a)=leftAmplification p n a := by
  ext ⟨i,k⟩ ⟨j,l⟩
  change Matrix.blockDiagonal (fun _ : Fin n => CStarMatrix.ofMatrix.symm a) (i,k) (j,l)=
    a i j*(1 : Matrix (Fin n) (Fin n) ℂ) k l
  by_cases h : k=l
  · subst l; simp
  · simp [Matrix.blockDiagonal_apply,h]

 def amplifiedUnitary (p n : ℕ) (u : unitary (Mat n)) : unitary (TensorMat p n) :=
   ⟨rightAmplification p n u,Unitary.map_mem (rightAmplification p n) u.2⟩

lemma amplifiedUnitary_continuous (p n : ℕ) : Continuous (amplifiedUnitary p n) := by
  exact ((map_continuous (rightAmplification p n)).comp continuous_subtype_val).subtype_mk _

theorem cluster_path_control (p n : ℕ) (v w : unitary (Mat n)) :
    ∃ γ : Path (amplifiedUnitary p n v) (amplifiedUnitary p n w),
      ∀ (f : Interval → Mat p) (x : Fin n → Interval) (c : Interval) (η : ℝ),
        0≤η → (∀ i,‖f (x i)-f c‖≤η) →
        ∀ t,‖unitaryConjugation (γ t) (blockDiagonalHom (fun i=>f (x i)))-
          blockDiagonalHom (fun i=>f (x i))‖≤2*η := by
  let γ := (finiteMatrixUnitaryPath v w).map (amplifiedUnitary_continuous p n)
  refine ⟨γ,?_⟩
  intro f x c η hη hf t
  have hc : Commute ((γ t : unitary (TensorMat p n)) : TensorMat p n)
      (leftAmplification p n (f c)) :=
    amplification_commute p n (f c) ((finiteMatrixUnitaryPath v w) t)
  apply (conjugation_near_commuting (γ t) _ _ hc).trans
  apply mul_le_mul_of_nonneg_left _ (by norm_num : (0:ℝ)≤2)
  rw [←blockDiagonal_constant p n,←map_sub]
  apply (NonUnitalStarAlgHom.norm_apply_le
    (blockDiagonalHom : (Fin n → Mat p) →⋆ₐ[ℂ] TensorMat p n) _).trans
  exact (pi_norm_le_iff_of_nonneg hη).mpr hf

end JiangSuConstruction


namespace JiangSuConstruction
open Complex NormedSpace selfAdjoint Unitary
open scoped CStarAlgebra ComplexOrder

lemma unitary_star_commute {A : Type*} [CStarAlgebra A]
    (u : unitary A) {b : A} (h : Commute (u:A) b) : Commute (star (u:A)) b := by
  have hh := congrArg (fun x : A => star (u:A)*x*star (u:A)) h.eq
  have hu := u.2.1
  have hv := u.2.2
  simp only [← mul_assoc,hu,one_mul] at hh
  have he : star (u:A)*b*(u:A)*star (u:A)=star (u:A)*b := by
    rw [mul_assoc, hv, mul_one]
  rw [he] at hh
  exact hh.symm

lemma unitary_argument_commute {A : Type*} [CStarAlgebra A]
    (u : unitary A) {b : A} (h : Commute (u:A) b) :
    Commute (argSelfAdjoint u : A) b := by
  rw [argSelfAdjoint_coe]
  exact h.cfc (unitary_star_commute u h) _

def finiteSpectrumLogPath {A : Type*} [CStarAlgebra A]
    (u : unitary A) (hf : (spectrum ℂ (u:A)).Finite) : Path 1 u where
  toFun t := expUnitary ((t:ℝ) • argSelfAdjoint u)
  continuous_toFun := by fun_prop
  source' := by simp
  target' := by simpa using finite_spectrum_unitary_exp u hf

lemma finiteSpectrumLogPath_commute {A : Type*} [CStarAlgebra A]
    (u : unitary A) (hf : (spectrum ℂ (u:A)).Finite) {b : A}
    (h : Commute (u:A) b) (t : unitInterval) :
    Commute (finiteSpectrumLogPath u hf t : A) b := by
  change Commute (exp (I • (((t:ℝ) • argSelfAdjoint u : selfAdjoint A) : A))) b
  change Commute (exp (I • ((t:ℝ) • (argSelfAdjoint u : A)))) b
  exact (((unitary_argument_commute u h).smul_left (t:ℝ)).smul_left I).exp_left

theorem finiteSpectrumLogPath_control {A : Type*} [CStarAlgebra A]
    (u : unitary A) (hf : (spectrum ℂ (u:A)).Finite) (a b : A)
    (h : Commute (u:A) b) (t : unitInterval) :
    ‖unitaryConjugation (finiteSpectrumLogPath u hf t) a-a‖≤2*‖a-b‖ :=
  conjugation_near_commuting _ a b (finiteSpectrumLogPath_commute u hf h t)

end JiangSuConstruction

end

end OAI