import OAI.Analysis.CStarAlgebra.PureInfiniteness.Stabilization

namespace OAI

noncomputable section
open Filter
open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace

namespace MainGap.Stable
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance matrixEntryOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance matrixEntryStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance algebraicTopology' : TopologicalSpace (Algebraic A) :=
  (inferInstance : PseudoMetricSpace (Algebraic A)).toUniformSpace.toTopologicalSpace

def paddedEntry (i j n : ℕ) (x : Mat A n) : A :=
  if hi : i < n then if hj : j < n then x ⟨i,hi⟩ ⟨j,hj⟩ else 0 else 0

lemma paddedEntry_pad (i j : ℕ) {n m : ℕ} (h : n ≤ m) (x : Mat A n) :
    paddedEntry i j m (pad h x) = paddedEntry i j n x := by
  by_cases hi : i < n <;> by_cases hj : j < n
  · have hi' := lt_of_lt_of_le hi h
    have hj' := lt_of_lt_of_le hj h
    simp [paddedEntry, hi, hj, hi', hj', pad_entry]
  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
      simp [paddedEntry, hi, hj, hi', hj', pad_entry]
  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
      simp [paddedEntry, hi, hi', hj', pad_entry]
  · by_cases hi' : i < m <;> by_cases hj' : j < m <;>
      simp [paddedEntry, hi, hi', hj', pad_entry]

def entryAlgLinear (i j : ℕ) : Algebraic A →ₗ[ℂ] A where
  toFun := DirectLimit.lift _ (paddedEntry i j) (fun _ _ h x => (paddedEntry_pad i j h x).symm)
  map_add' := DirectLimit.induction₂ _ fun n x y => by
    rw [DirectLimit.add_def]
    change paddedEntry i j n (x+y) = paddedEntry i j n x + paddedEntry i j n y
    by_cases hi : i < n <;> by_cases hj : j < n <;> simp [paddedEntry, hi, hj]
  map_smul' c := DirectLimit.induction _ fun n x => by
    rw [DirectLimit.smul_def]
    change paddedEntry i j n (c • x) = c • paddedEntry i j n x
    by_cases hi : i < n <;> by_cases hj : j < n <;> simp [paddedEntry, hi, hj]

@[simp] lemma entryAlgLinear_corner (i j n : ℕ) (x : Mat A n) :
    entryAlgLinear i j (cornerAlg n x) = paddedEntry i j n x := rfl

lemma norm_entryAlgLinear_le (i j : ℕ) (x : Algebraic A) :
    ‖entryAlgLinear i j x‖ ≤ ‖x‖ := by
  induction x using DirectLimit.induction with
  | ih n x =>
    change ‖paddedEntry i j n x‖ ≤ ‖x‖
    by_cases hi : i < n <;> by_cases hj : j < n
    · simpa [paddedEntry, hi, hj] using
        (CStarMatrix.norm_entry_le_norm (M := x) (i := ⟨i,hi⟩) (j := ⟨j,hj⟩))
    all_goals simp [paddedEntry, hi, hj]

def entryAlg (i j : ℕ) : Algebraic A →L[ℂ] A :=
  (entryAlgLinear i j).mkContinuous 1 (fun x => by simpa using norm_entryAlgLinear_le i j x)

def entry (i j : ℕ) : Stabilization A → A :=
  UniformSpace.Completion.extension (entryAlg (A := A) i j)

lemma continuous_entry (i j : ℕ) : Continuous (entry (A := A) i j) :=
  UniformSpace.Completion.continuous_extension

@[simp] lemma entry_coe (i j : ℕ) (x : Algebraic A) :
    entry i j (x : Stabilization A) = entryAlg (A := A) i j x := by
  unfold entry
  exact UniformSpace.Completion.extension_coe (f := (entryAlg (A := A) i j))
    (ContinuousLinearMap.uniformContinuous (entryAlg (A := A) i j)) x

@[simp] lemma entry_corner (i j n : ℕ) (x : Mat A n) :
    entry i j (corner n x) = paddedEntry i j n x := by
  rw [corner_apply, entry_coe]
  rfl

def block (m n : ℕ) (x : Stabilization A) : CStarMatrix (Fin m) (Fin n) A :=
  CStarMatrix.ofMatrix fun i j => entry i.val j.val x

@[simp] lemma block_apply (m n : ℕ) (x : Stabilization A) (i : Fin m) (j : Fin n) :
    block m n x i j = entry i.val j.val x := rfl

lemma continuous_block (m n : ℕ) : Continuous (block (A := A) m n) := by
  exact continuous_pi fun i => continuous_pi fun j => (continuous_entry i.val j.val)

@[simp] lemma block_corner_self (n : ℕ) (x : Mat A n) : block n n (corner n x) = x := by
  ext i j
  simp only [block_apply, entry_corner, paddedEntry, dite_eq_left i.isLt, dite_eq_left j.isLt]

end MainGap.Stable

namespace MainGap.Stable
variable {A : Type*} [NonUnitalCStarAlgebra A]
local instance blockConjugateOrder : PartialOrder A := CStarAlgebra.spectralOrder A
local instance blockConjugateStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A
local instance algebraicTopology'' : TopologicalSpace (Algebraic A) :=
  (inferInstance : PseudoMetricSpace (Algebraic A)).toUniformSpace.toTopologicalSpace

lemma paddedEntry_star (i j n : ℕ) (x : Mat A n) :
    paddedEntry i j n (star x) = star (paddedEntry j i n x) := by
  by_cases hi : i < n <;> by_cases hj : j < n <;>
    simp [paddedEntry, hi, hj, CStarMatrix.star_apply]

lemma paddedEntry_mul (i j n : ℕ) (x y : Mat A n) :
    paddedEntry i j n (x*y) =
      ∑ k : Fin n, paddedEntry i k.val n x * paddedEntry k.val j n y := by
  by_cases hi : i < n <;> by_cases hj : j < n <;>
    simp [paddedEntry, hi, hj, CStarMatrix.mul_apply]

lemma paddedEntry_conjugate (i j : ℕ) {m N : ℕ} (h : m ≤ N)
    (z : Mat A N) (v : Mat A m) :
    paddedEntry i j N (star z * pad h v * z) =
      ∑ q : Fin m, ∑ p : Fin m,
        star (paddedEntry p.val i N z) * v p q * paddedEntry q.val j N z := by
  classical
  simp only [paddedEntry_mul, paddedEntry_star, paddedEntry_pad]
  rw [← sum_pad h (fun q : Fin m => ∑ p : Fin m,
      star (paddedEntry p.val i N z) * v p q * paddedEntry q.val j N z)]
  apply Finset.sum_congr rfl
  intro q _
  by_cases hq : q.val < m
  · rw [dite_eq_left hq, Finset.sum_mul]
    rw [← sum_pad h (fun p : Fin m =>
      star (paddedEntry p.val i N z) * v p ⟨q,hq⟩ * paddedEntry q.val j N z)]
    apply Finset.sum_congr rfl
    intro p _
    by_cases hp : p.val < m <;> simp [paddedEntry, hp, hq]
  · simp [paddedEntry, hq]

lemma block_conjugate_corner {m N : ℕ} (h : m ≤ N) (n : ℕ)
    (v : Mat A m) (z : Mat A N) :
    block n n (star (corner N z) * corner m v * corner N z) =
      (block m n (corner N z)).conjTranspose * v * block m n (corner N z) := by
  rw [← corner_pad h v]
  have he : star (corner N z) * corner N (pad h v) * corner N z =
      corner N (star z * pad h v * z) := by rw [map_mul, map_mul, map_star]
  rw [he]
  ext i j
  simp only [block_apply, entry_corner, CStarMatrix.mul_apply,
    CStarMatrix.conjTranspose_apply, Finset.sum_mul]
  exact paddedEntry_conjugate i.val j.val h z v

lemma block_conjugate (m n : ℕ) (v : Mat A m) (x : Stabilization A) :
    block n n (star x * corner m v * x) =
      (block m n x).conjTranspose * v * block m n x := by
  refine UniformSpace.Completion.induction_on x ?_ ?_
  · apply isClosed_eq
    · exact (continuous_block n n).comp ((continuous_star.mul continuous_const).mul continuous_id)
    · have hc : Continuous (fun x : Stabilization A => (block m n x).conjTranspose) := by
        change Continuous (fun x : Stabilization A =>
          fun i j => star (block m n x j i))
        exact continuous_pi fun i => continuous_pi fun j =>
          continuous_star.comp (continuous_entry j.val i.val)
      exact (hc.matrix_mul continuous_const).matrix_mul (continuous_block m n)
  · intro z
    induction z using DirectLimit.induction with
    | ih k z =>
      change block n n (star (corner k z) * corner m v * corner k z) =
        (block m n (corner k z)).conjTranspose * v * block m n (corner k z)
      rw [← corner_pad (le_max_right m k) z]
      exact block_conjugate_corner (le_max_left m k) n v _

end MainGap.Stable

end

end OAI