import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.DimensionDrop.Spectra
import OAI.Analysis.JiangSu.DimensionDrop.IteratedSpectrum
import OAI.Analysis.JiangSu.MatrixAlgebras.MatrixDiagonalComposition

namespace OAI


noncomputable section
namespace OriginalJiangSu
open JiangSuConstruction

def stageMultiplicities (n : ℕ) := multiplicities (pair n)
def IteratedIndex (n : ℕ) : ℕ → Type
  | 0 => PUnit
  | k+1 => IteratedIndex n k × Index (stageMultiplicities (n+k))
instance iteratedFintype (n : ℕ) : (k : ℕ) → Fintype (IteratedIndex n k)
  | 0 => inferInstanceAs (Fintype PUnit)
  | k+1 => letI := iteratedFintype n k
    inferInstanceAs (Fintype (IteratedIndex n k × Index (stageMultiplicities (n+k))))
instance iteratedDecEq (n : ℕ) : (k : ℕ) → DecidableEq (IteratedIndex n k)
  | 0 => inferInstanceAs (DecidableEq PUnit)
  | k+1 => letI := iteratedDecEq n k
    inferInstanceAs (DecidableEq (IteratedIndex n k × Index (stageMultiplicities (n+k))))
instance iteratedNonempty (n : ℕ) : (k : ℕ) → Nonempty (IteratedIndex n k)
  | 0 => inferInstanceAs (Nonempty PUnit)
  | k+1 =>
    letI := iteratedNonempty n k
    letI : Nonempty (Index (stageMultiplicities (n+k))) :=
      ⟨Sum.inl ⟨0,(stageMultiplicities (n+k)).lower_pos⟩⟩
    inferInstanceAs (Nonempty (IteratedIndex n k × Index (stageMultiplicities (n+k))))

def iteratedFamily (n : ℕ) : (k : ℕ) → IteratedIndex n k → C(Interval,Interval)
  | 0,_ => ContinuousMap.id _
  | k+1,z => (iteratedFamily n k z.1).comp (family (stageMultiplicities (n+k)) z.2)

lemma iterated_contract (n k : ℕ) (j : IteratedIndex n k) (s t : Interval) :
    |(iteratedFamily n k j s).1-(iteratedFamily n k j t).1|≤(1/2:ℝ)^k*|s.1-t.1| := by
  induction k generalizing s t with
  | zero => simp [iteratedFamily]
  | succ k ih =>
    change |(iteratedFamily n k j.1 (family (stageMultiplicities (n+k)) j.2 s)).1-
      (iteratedFamily n k j.1 (family (stageMultiplicities (n+k)) j.2 t)).1|≤_
    calc
      _≤(1/2:ℝ)^k*|(family (stageMultiplicities (n+k)) j.2 s).1-
        (family (stageMultiplicities (n+k)) j.2 t).1| := ih j.1 _ _
      _≤(1/2:ℝ)^k*(|s.1-t.1|/2) := mul_le_mul_of_nonneg_left (family_contract _ _ _ _) (by positivity)
      _=(1/2:ℝ)^(k+1)*|s.1-t.1| := by rw [pow_succ]; ring

lemma iterated_variation (n k : ℕ) (j : IteratedIndex n k) (s t : Interval) :
    dist (iteratedFamily n k j s) (iteratedFamily n k j t) ≤ (1/2:ℝ)^k := by
  have habs : |s.1-t.1|≤1 := by rw [abs_le]; constructor <;> linarith [s.2.1,s.2.2,t.2.1,t.2.2]
  exact (iterated_contract n k j s t).trans
    (mul_le_of_le_one_right (by positivity) habs)

open scoped CStarAlgebra ComplexOrder

local instance diagIteratedDecEq (n : ℕ) : (k : ℕ) → DecidableEq (IteratedIndex n k)
  | 0 => inferInstanceAs (DecidableEq PUnit)
  | k+1 => letI := diagIteratedDecEq n k
    inferInstanceAs (DecidableEq (IteratedIndex n k × Index (stageMultiplicities (n+k))))

def stepUnitary (n : ℕ) : C(Interval,unitary (TensorMat (pair (n+1)).p (pair (n+1)).q)) :=
  (finiteMatrixUnitaryPath
    (permutationUnitary ((zeroIndexEquiv (stageMultiplicities n)).symm.trans
      (zeroIndexEquiv (stageMultiplicities n))))
    (permutationUnitary ((zeroIndexEquiv (stageMultiplicities n)).symm.trans
      (oneIndexEquiv (stageMultiplicities n))))).toContinuousMap

lemma stageStep_eval (n : ℕ) (f : Stage n) (t : Interval) :
    (stageStep n f).val t=unitaryConjugation (stepUnitary n t)
      (CStarMatrix.reindexₐ ℂ ℂ (zeroIndexEquiv (stageMultiplicities n))
        (blockDiagonalHom (fun z => f.val (family (stageMultiplicities n) z t)))) := rfl

theorem iterate_diagonalization (n k : ℕ) :
    ∃ e : ((Fin (pair n).p×Fin (pair n).q)×IteratedIndex n k) ≃
        (Fin (pair (n+k)).p×Fin (pair (n+k)).q),
    ∃ V : C(Interval,unitary (TensorMat (pair (n+k)).p (pair (n+k)).q)),
    ∀ f : Stage n,∀ t : Interval,
      (system.map (Nat.le_add_right n k) f).val t=
        unitaryConjugation (V t) (CStarMatrix.reindexₐ ℂ ℂ e
          (blockDiagonalHom (fun i => f.val (iteratedFamily n k i t)))) := by
  classical
  induction k with
  | zero =>
    refine ⟨Equiv.prodPUnit _,1,?_⟩
    intro f t
    change (SequentialCStar.sequenceHom stageStep (le_refl n) f).val t=
      unitaryConjugation 1 (CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodPUnit _)
        (blockDiagonalHom (fun _ : PUnit.{1} => f.val t)))
    rw [SequentialCStar.sequenceHom_self,unitaryConjugation_one,block_punit]
  | succ k ih =>
    obtain ⟨e,V,hV⟩ := ih
    let ξ := family (stageMultiplicities (n+k))
    let E := zeroIndexEquiv (stageMultiplicities (n+k))
    let R := (CStarMatrix.reindexₐ ℂ ℂ E).toStarAlgHom
    let e' := ((Equiv.prodAssoc (Fin (pair n).p×Fin (pair n).q)
      (IteratedIndex n k) (Index (stageMultiplicities (n+k)))).symm.trans
      (Equiv.prodCongr e (Equiv.refl _))).trans E
    let T := Fin (pair (n+k)).p×Fin (pair (n+k)).q
    let K := Index (stageMultiplicities (n+k))
    let B : C(Interval,unitary (CStarMatrix (T×K) (T×K) ℂ)) :=
      ⟨fun t => blockUnitary (fun z => V (ξ z t)),
        blockUnitary_continuous.comp (continuous_pi fun z => V.continuous.comp (ξ z).continuous)⟩
    let V' := stepUnitary (n+k) *
      (⟨fun t => homUnitary R (B t), (homUnitary_continuous R).comp B.continuous⟩ :
        C(Interval,unitary (TensorMat (pair (n+k+1)).p (pair (n+k+1)).q)))
    refine ⟨e',V',?_⟩
    intro f t
    change (SequentialCStar.sequenceHom stageStep
      ((Nat.le_add_right n k).trans (Nat.le_succ (n+k))) f).val t=_
    rw [SequentialCStar.sequenceHom_succ,stageStep_eval]
    change unitaryConjugation (stepUnitary (n+k) t)
      (R (blockDiagonalHom (fun z => (system.map (Nat.le_add_right n k) f).val (ξ z t))))=_
    have hfun : (fun z => (system.map (Nat.le_add_right n k) f).val (ξ z t))=
        (fun z => unitaryConjugation (V (ξ z t)) (CStarMatrix.reindexₐ ℂ ℂ e
          (blockDiagonalHom (fun i => f.val (iteratedFamily n k i (ξ z t)))))) := by
      funext z
      exact hV f (ξ z t)
    rw [hfun]
    exact diagonalization_comp (stepUnitary (n+k) t) (fun z => V (ξ z t)) e E
      (fun i : IteratedIndex n k×Index (stageMultiplicities (n+k)) =>
        f.val (iteratedFamily n k i.1 (ξ i.2 t)))

end OriginalJiangSu

end

end OAI