import OAI.Analysis.CharacterCriterion.DropSections

namespace OAI

noncomputable section
open scoped TensorProduct
open scoped InnerProductSpace
open scoped BigOperators
open Set Module
open Topology
open NormedSpace
open scoped ComplexOrder
open scoped ComplexOrder
open scoped InnerProductSpace
open scoped InnerProductSpace
open NormedSpace
open scoped TensorProduct InnerProductSpace
open UniformSpace
variable [KirchbergRordam.GenericRW.Size]
local notation "rankNum" => KirchbergRordam.GenericRW.Size.n


namespace KirchbergRordam.GenericRW.OrderZero.Pair
open scoped Matrix Kronecker BigOperators
open IntervalCalculus
variable {ι κ A : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
variable [CStarAlgebra A] [Nontrivial A] [PartialOrder A] [StarOrderedRing A]
variable (P : Pair ι κ A)
local instance : SMul ℂ P.field.Domain := (NonUnitalStarSubalgebra.instModule P.field.Domain).toSMul

def weighted : Matrix (ι×κ) (ι×κ) ℂ →ₗ[ℂ] P.field.Matrices where
  toFun m u v := Vanish.multiplier P.weight (ContinuousMap.const _ (m u v))
  map_add' m n := by ext u v t; change P.weight t*(m u v+n u v)=P.weight t*m u v+P.weight t*n u v; ring
  map_smul' z m := by ext u v t; change P.weight t*(z*m u v)=z*(P.weight t*m u v); ring

lemma weighted_coeff (u v : ι×κ) (z : ℂ) :
    P.field.coeff u v (Vanish.multiplier P.weight (ContinuousMap.const _ z)) = z • P.field.x u v := by
  change P.field.coeff u v (Vanish.multiplier P.field.p (ContinuousMap.const _ z)) = _
  rw [P.field.coeff_mul]
  have he : ContinuousMap.const unitInterval z=z • (1:C(unitInterval,ℂ)) := by ext t; simp
  rw [he,map_smul,map_one,mul_smul_comm,mul_one]

lemma weighted_single (u v : ι×κ) (z : ℂ) :
    P.weighted (Matrix.single u v z)=
      Matrix.single u v (Vanish.multiplier P.weight (ContinuousMap.const _ z)) := by
  ext i j t
  change P.weight t * (Matrix.single u v z) i j =
    ((Matrix.single u v (Vanish.multiplier P.weight (ContinuousMap.const _ z))) i j).val t
  by_cases hi : u=i <;> by_cases hj : v=j <;> simp [Matrix.single,hi,hj]

lemma weighted_kronecker (a : Matrix ι ι ℂ) (b : Matrix κ κ ℂ) :
    P.field.matrices (P.weighted (a ⊗ₖ b)) = P.left.linear a*P.right.linear b := by
  induction a using Matrix.induction_on' with
  | h_zero => simp
  | h_add a a' ha ha' => simp only [Matrix.add_kronecker,map_add,add_mul,ha,ha']
  | h_std_basis i j z =>
    induction b using Matrix.induction_on' with
    | h_zero => simp
    | h_add b b' hb hb' => simp only [Matrix.kronecker_add,map_add,mul_add,hb,hb']
    | h_std_basis k l w =>
      rw [Matrix.single_kronecker_single,P.weighted_single]
      change P.field.matrices (Matrix.single (i,k) (j,l)
        (Vanish.multiplier P.field.p (ContinuousMap.const _ (z*w)))) = _
      rw [P.field.matrices_single]
      change P.field.coeff (i,k) (j,l)
        (Vanish.multiplier P.weight (ContinuousMap.const _ (z*w))) = _
      rw [P.weighted_coeff,P.left.linear_single,P.right.linear_single]
      change (z*w) • (P.left.x i j*P.right.x k l) = _
      rw [smul_mul_assoc,mul_smul_comm,smul_smul]

lemma weighted_left (a : Matrix ι ι ℂ) :
    P.field.matrices (P.weighted (a ⊗ₖ (1:Matrix κ κ ℂ))) = P.left.linear a*P.right.h := by
  rw [P.weighted_kronecker,P.right.linear_one]

lemma weighted_right (b : Matrix κ κ ℂ) :
    P.field.matrices (P.weighted ((1:Matrix ι ι ℂ) ⊗ₖ b)) = P.left.h*P.right.linear b := by
  rw [P.weighted_kronecker,P.left.linear_one]

def actionLeft (a : Matrix ι ι ℂ) (m : P.field.Matrices) : P.field.Matrices :=
  fun u v => ∑ j, (@HSMul.hSMul ℂ P.field.Domain P.field.Domain inferInstance (a u.1 j) (P.field.scalarMul (1-coord) (m (j,u.2) v)))

def actionRight (a : Matrix κ κ ℂ) (m : P.field.Matrices) : P.field.Matrices :=
  fun u v => ∑ j, (@HSMul.hSMul ℂ P.field.Domain P.field.Domain inferInstance (a u.2 j) (P.field.scalarMul coord (m (u.1,j) v)))

lemma left_x_matrices (i j : ι) (m : P.field.Matrices) :
    P.left.x i j*P.field.matrices m =
      ∑ l : κ,∑ v : ι×κ, P.field.coeff (i,l) v (P.field.scalarMul (1-coord) (m (j,l) v)) := by
  simp only [FieldCalculus.Data.matrices,LinearMap.coe_mk,AddHom.coe_mk,
    Finset.mul_sum,P.left_x_coeff,Fintype.sum_prod_type]
  simp only [Finset.sum_ite_irrel,Finset.sum_const_zero,Finset.sum_ite_eq,Finset.mem_univ,ite_true]

lemma right_x_matrices (i j : κ) (m : P.field.Matrices) :
    P.right.x i j*P.field.matrices m =
      ∑ k : ι,∑ v : ι×κ, P.field.coeff (k,i) v (P.field.scalarMul coord (m (k,j) v)) := by
  simp only [FieldCalculus.Data.matrices,LinearMap.coe_mk,AddHom.coe_mk,
    Finset.mul_sum,P.right_x_coeff,Fintype.sum_prod_type]
  simp only [Finset.sum_ite_irrel,Finset.sum_const_zero,Finset.sum_ite_eq,Finset.mem_univ,ite_true]

lemma linear_field_left (a : Matrix ι ι ℂ) (m : P.field.Matrices) :
    P.left.linear a*P.field.matrices m = P.field.matrices (P.actionLeft a m) := by
  change (∑ i,∑ j,a i j • P.left.x i j)*P.field.matrices m = _
  conv_lhs =>
    simp only [Finset.sum_mul,smul_mul_assoc,P.left_x_matrices,Finset.smul_sum]
  change (∑ i,∑ j,∑ l,∑ v,a i j • P.field.coeff (i,l) v
    (P.field.scalarMul (1-coord) (m (j,l) v))) = _
  simp only [FieldCalculus.Data.matrices,LinearMap.coe_mk,AddHom.coe_mk,actionLeft,
    Fintype.sum_prod_type,map_sum,map_smul]
  apply Finset.sum_congr rfl
  intro i _
  conv_lhs => rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro l _
  conv_lhs => rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro k _
  rw [Finset.sum_comm]

lemma linear_field_right (a : Matrix κ κ ℂ) (m : P.field.Matrices) :
    P.right.linear a*P.field.matrices m = P.field.matrices (P.actionRight a m) := by
  change (∑ i,∑ j,a i j • P.right.x i j)*P.field.matrices m = _
  conv_lhs =>
    simp only [Finset.sum_mul,smul_mul_assoc,P.right_x_matrices,Finset.smul_sum]
  change (∑ i,∑ j,∑ k,∑ v,a i j • P.field.coeff (k,i) v
    (P.field.scalarMul coord (m (k,j) v))) = _
  simp only [FieldCalculus.Data.matrices,LinearMap.coe_mk,AddHom.coe_mk,actionRight,
    Fintype.sum_prod_type,map_sum,map_smul]
  conv_lhs =>
    arg 2; ext i
    rw [Finset.sum_comm]
  conv_lhs => rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro k _
  apply Finset.sum_congr rfl
  intro i _
  conv_lhs => rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro l _
  rw [Finset.sum_comm]

end KirchbergRordam.GenericRW.OrderZero.Pair

namespace KirchbergRordam.GenericRW.OrderZero.Pair
open scoped Matrix Kronecker BigOperators ComplexOrder
variable {A : Type*} [CStarAlgebra A] [Nontrivial A] [PartialOrder A] [StarOrderedRing A]
variable (P : Pair (Fin rankNum) (Fin (rankNum+1)) A)

lemma interior_matrices_star (m : DropSections.Interior) :
    P.field.matrices (star m) = star (P.field.matrices m) :=
  P.field.matrices_star m

lemma interior_matrices_product (m n : DropSections.Interior) :
    P.field.matrices (m*n) = P.field.matrices m * P.field.matrices n :=
  P.field.matrices_product m n

lemma interior_matrices_add (m n : DropSections.Interior) :
    P.field.matrices (m+n) = P.field.matrices m + P.field.matrices n :=
  P.field.matrices.map_add m n

lemma interior_matrices_sub (m n : DropSections.Interior) :
    P.field.matrices (m-n) = P.field.matrices m - P.field.matrices n :=
  map_sub P.field.matrices m n

lemma interior_matrices_neg (m : DropSections.Interior) :
    P.field.matrices (-m) = -P.field.matrices m :=
  map_neg P.field.matrices m

lemma interior_matrices_zero : P.field.matrices (0 : DropSections.Interior) = 0 :=
  map_zero P.field.matrices

omit [Nontrivial A] [StarOrderedRing A] in
lemma left_linear_commute_h (a : DropSections.Small2) : Commute (P.left.linear a) P.right.h := by
  change Commute (∑ i,∑ j,a i j • P.left.x i j) P.right.h
  exact Commute.sum_left _ _ _ fun i _ =>
    Commute.sum_left _ _ _ fun j _ => (P.left_commute_right_h i j).smul_left (a i j)

omit [Nontrivial A] [StarOrderedRing A] in
lemma left_right_linear_commute (a : DropSections.Small2) (b : DropSections.Small3) :
    Commute (P.left.linear a) (P.right.linear b) := by
  change Commute (∑ i,∑ j,a i j • P.left.x i j) (∑ k,∑ l,b k l • P.right.x k l)
  exact Commute.sum_left _ _ _ fun i _ => Commute.sum_left _ _ _ fun j _ =>
    Commute.sum_right _ _ _ fun k _ => Commute.sum_right _ _ _ fun l _ =>
      ((P.commute i j k l).smul_left (a i j)).smul_right (b k l)

lemma left_product (a c : DropSections.Small2) :
    P.left.linear a*P.left.linear c = P.left.linear (a*c)-P.field.matrices
      (DropSections.weighted ((a*c) ⊗ₖ (1:DropSections.Small3))) := by
  change _=P.left.linear (a*c)-P.field.matrices (P.weighted ((a*c) ⊗ₖ 1))
  rw [P.left.linear_mul,P.weighted_left,P.left_h,sub_mul,one_mul,
    (P.left_linear_commute_h (a*c)).eq]

lemma right_product (b d : DropSections.Small3) :
    P.right.linear b*P.right.linear d = P.right.linear (b*d)-P.field.matrices
      (DropSections.weighted ((1:DropSections.Small2) ⊗ₖ (b*d))) := by
  change _=P.right.linear (b*d)-P.field.matrices (P.weighted (1 ⊗ₖ (b*d)))
  rw [P.right.linear_mul,P.weighted_right]
  have he : P.right.h=1-P.left.h := (eq_sub_iff_add_eq).mpr (by rw [add_comm,P.sum_one])
  rw [he,sub_mul,one_mul]

lemma cross_product (a : DropSections.Small2) (b : DropSections.Small3) :
    P.left.linear a*P.right.linear b=P.field.matrices (DropSections.weighted (a ⊗ₖ b)) :=
  (P.weighted_kronecker a b).symm

lemma cross_product_rev (a : DropSections.Small2) (b : DropSections.Small3) :
    P.right.linear b*P.left.linear a=P.field.matrices (DropSections.weighted (a ⊗ₖ b)) := by
  rw [← (P.left_right_linear_commute a b).eq,P.cross_product]

lemma field_left (a : DropSections.Small2) (m : DropSections.Interior) :
    P.left.linear a*P.field.matrices m=P.field.matrices (DropSections.actionLeft a m) :=
  P.linear_field_left a m

lemma field_right (b : DropSections.Small3) (m : DropSections.Interior) :
    P.right.linear b*P.field.matrices m=P.field.matrices (DropSections.actionRight b m) :=
  P.linear_field_right b m

lemma field_left_rev (a : DropSections.Small2) (m : DropSections.Interior) :
    P.field.matrices m*P.left.linear a=P.field.matrices (DropSections.actionLeftRev m a) := by
  calc
    _ = star (star (P.left.linear a) * star (P.field.matrices m)) := by
      rw [star_mul, star_star, star_star]
    _ = star (P.left.linear (star a) * P.field.matrices (star m)) :=
      congrArg star (congrArg₂ (· * ·) (P.left.linear_star a).symm
        (P.interior_matrices_star m).symm)
    _ = star (P.field.matrices (DropSections.actionLeft (star a) (star m))) :=
      congrArg star (P.field_left _ _)
    _ = _ := (P.interior_matrices_star _).symm

lemma field_right_rev (b : DropSections.Small3) (m : DropSections.Interior) :
    P.field.matrices m*P.right.linear b=P.field.matrices (DropSections.actionRightRev m b) := by
  calc
    _ = star (star (P.right.linear b) * star (P.field.matrices m)) := by
      rw [star_mul, star_star, star_star]
    _ = star (P.right.linear (star b) * P.field.matrices (star m)) :=
      congrArg star (congrArg₂ (· * ·) (P.right.linear_star b).symm
        (P.interior_matrices_star m).symm)
    _ = star (P.field.matrices (DropSections.actionRight (star b) (star m))) :=
      congrArg star (P.field_right _ _)
    _ = _ := (P.interior_matrices_star _).symm


def liftLinear : DimensionDrop23 →ₗ[ℂ] A :=
  P.left.linear.comp DropSections.endLeft + P.right.linear.comp DropSections.endRight +
    P.field.matrices.comp DropSections.interior

lemma lift_apply (f : DimensionDrop23) : P.liftLinear f=
    P.left.linear (DropSections.endLeft f)+P.right.linear (DropSections.endRight f)+
      P.field.matrices (DropSections.interior f) := rfl

lemma lift_mul (f g : DimensionDrop23) : P.liftLinear (f*g)=P.liftLinear f*P.liftLinear g := by
  simp only [P.lift_apply,DropSections.endLeft_mul,DropSections.endRight_mul,DropSections.interior_mul,
    P.interior_matrices_add,P.interior_matrices_sub,P.interior_matrices_neg,
    P.interior_matrices_product]
  simp only [add_mul,mul_add,P.left_product,P.right_product,P.cross_product,P.cross_product_rev,
    P.field_left,P.field_right,P.field_left_rev,P.field_right_rev]
  abel

lemma lift_one : P.liftLinear 1=1 := by
  rw [P.lift_apply,DropSections.endLeft_one,DropSections.endRight_one,DropSections.interior_one,
    P.interior_matrices_zero,add_zero,P.left.linear_one,P.right.linear_one,P.sum_one]

lemma lift_star (f : DimensionDrop23) : P.liftLinear (star f)=star (P.liftLinear f) := by
  simp only [P.lift_apply,DropSections.endLeft_star,DropSections.endRight_star,DropSections.interior_star,
    P.left.linear_star,P.right.linear_star,star_add]
  exact congrArg (fun value => star (P.left.linear (DropSections.endLeft f)) +
    star (P.right.linear (DropSections.endRight f)) + value)
    (P.interior_matrices_star (DropSections.interior f))


def dimensionDropHom : DimensionDrop23 →⋆ₐ[ℂ] A where
  toFun := P.liftLinear
  map_zero' := map_zero P.liftLinear
  map_one' := P.lift_one
  map_add' := map_add P.liftLinear
  map_mul' := P.lift_mul
  commutes' c := by simp only [Algebra.algebraMap_eq_smul_one,map_smul,P.lift_one]
  map_star' := P.lift_star

end KirchbergRordam.GenericRW.OrderZero.Pair

namespace KirchbergRordam.GenericRW.OrderZero.WeightedUnits
open scoped BigOperators CStarAlgebra
variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
variable {ι : Type*} [Fintype ι] [DecidableEq ι]
variable (W : WeightedUnits ι A)

lemma mul_eq_zero_of_total {z : A} (hz : W.h*z=0) (i j : ι) : W.x i j*z=0 := by
  apply norm_eq_zero.mp
  apply le_antisymm _ (norm_nonneg _)
  simpa only [hz,norm_zero] using W.norm_mul_le i j z


lemma commute_of_total_commutator (y : A) (hy : Commute y W.h) (i j : ι)
    (hz : W.h*(y*W.x i j-W.x i j*y)=0) : Commute y (W.x i j) := by
  let z := y*W.x i j-W.x i j*y
  have hy' : Commute (star y) W.h := by
    simpa only [(IsSelfAdjoint.of_nonneg W.nonneg).star_eq] using hy.star_star
  have h₁ : W.x j i*z=0 := W.mul_eq_zero_of_total hz j i
  have h₂ : W.x j i*(star y*z)=0 := by
    apply W.mul_eq_zero_of_total
    rw [← mul_assoc,hy'.symm.eq,mul_assoc,hz,mul_zero]
  have he : star z*z=0 := by
    dsimp only [z] at h₁ h₂ ⊢
    rw [star_sub,star_mul,star_mul,W.star_x,sub_mul,mul_assoc (W.x j i),h₂,
      mul_assoc (star y),h₁,mul_zero,sub_self]
  have hn : ‖z‖*‖z‖=0 := by rw [← CStarRing.norm_star_mul_self,he,norm_zero]
  have zz : z=0 := norm_eq_zero.mp (mul_self_eq_zero.mp hn)
  exact sub_eq_zero.mp zz


lemma commute_of_spokes (r : ι) (hd : ∀ i,0≤W.x i i) (y : A)
    (hy : ∀ i,Commute y (W.x i r)) (hy' : ∀ i,Commute y (W.x r i)) :
    ∀ i j,Commute y (W.x i j) := by
  have hc (i : ι) : Commute y (W.x i i) := by
    have he : W.x i r*W.x r i=W.x i i*W.x i i := by simp only [W.mul_x,ite_true]
    have ht := ((hy i).mul_right (hy' i)).symm.cfcₙ_nnreal NNReal.sqrt
    change Commute (CFC.sqrt (W.x i r*W.x r i)) y at ht
    rw [he,CFC.sqrt_mul_self _ (hd i)] at ht
    exact ht.symm
  have htotal : Commute y W.h := by
    rw [← W.diagonal]
    exact Commute.sum_right Finset.univ (fun i => W.x i i) y fun i _ => hc i
  intro i j
  apply W.commute_of_total_commutator y htotal
  have hh := (hy i).mul_right (hy' j)
  rw [W.mul_x,ite_eq_left rfl] at hh
  change y*(W.h*W.x i j)=(W.h*W.x i j)*y at hh
  calc
    _=y*(W.h*W.x i j)-(W.h*W.x i j)*y := by
      rw [mul_sub,← mul_assoc,htotal.symm.eq]; noncomm_ring
    _=0 := sub_eq_zero.mpr hh

end KirchbergRordam.GenericRW.OrderZero.WeightedUnits

namespace KirchbergRordam.GenericRW.OrderZero.WeightedUnits
open scoped CStarAlgebra BigOperators
open ConeModel FlipPath HereditaryTransport RWFunctions
variable {A : Type*} [CStarAlgebra A] [Nontrivial A] [PartialOrder A] [StarOrderedRing A]
variable (W : WeightedUnits (Fin rankNum) A)
variable {v : A} (hv : star v*v=1-W.h) (h0 : W.x 0 0*v=v)

lemma rwAlpha_diagonal (i : Fin (rankNum+1)) : 0 ≤ (W.rwAlpha hv h0).x i i := by
  change 0 ≤ star (triple W.defect_selfAdjoint (W.polarVectors v) W.rwK W.rwQ i)*
    triple W.defect_selfAdjoint (W.polarVectors v) W.rwK W.rwQ i
  exact star_mul_self_nonneg _

lemma rwAlpha_corner : (W.rwAlpha hv h0).x (Fin.last rankNum) (Fin.last rankNum)=(W.rwH:A) := by
  change star (triple W.defect_selfAdjoint (W.polarVectors v) W.rwK W.rwQ (Fin.last rankNum)) *
    triple W.defect_selfAdjoint (W.polarVectors v) W.rwK W.rwQ (Fin.last rankNum) = (W.rwH:A)
  rw [triple_last]
  rw [show star (W.rwQ:A)=(W.rwQ:A) from congrArg Subtype.val W.rwQ_star]
  exact congrArg Subtype.val W.rwQ_sq

lemma rw_commute_corner (j k : Fin rankNum) :
    Commute ((W.rwBeta hv h0).x j k) ((W.rwAlpha hv h0).x (Fin.last rankNum) (Fin.last rankNum)) := by
  rw [W.rwAlpha_corner hv h0,W.rwH_val]
  change Commute (W.rwL hv h0*W.toWeightedMatrix.eval RWFunctions.j*W.x j k)
    (W.toWeightedMatrix.eval g)
  exact ((W.rwL_commute_scalar hv h0 g).mul_left
    ((Commute.all RWFunctions.j g).map W.toWeightedMatrix.eval)).mul_left
      (W.toWeightedMatrix.commute_eval j k g)

lemma rw_commute_row (i : Fin (rankNum+1)) (j k : Fin rankNum) :
    Commute ((W.rwBeta hv h0).x j k) ((W.rwAlpha hv h0).x i (Fin.last rankNum)) := by
  induction i using Fin.lastCases with
  | last => exact W.rw_commute_corner hv h0 j k
  | cast i => exact W.rw_commute_spoke hv h0 i j k

lemma rw_commute_col (i : Fin (rankNum+1)) (j k : Fin rankNum) :
    Commute ((W.rwBeta hv h0).x j k) ((W.rwAlpha hv h0).x (Fin.last rankNum) i) := by
  have h := (W.rw_commute_row hv h0 i k j).star_star
  simpa only [(W.rwBeta hv h0).star_x,(W.rwAlpha hv h0).star_x] using h


def rwPair : OrderZero.Pair (Fin rankNum) (Fin (rankNum+1)) A where
  left := W.rwBeta hv h0
  right := W.rwAlpha hv h0
  commute j k := (W.rwAlpha hv h0).commute_of_spokes (Fin.last rankNum) (W.rwAlpha_diagonal hv h0) _
    (fun i => W.rw_commute_row hv h0 i j k) (fun i => W.rw_commute_col hv h0 i j k)
  sum_one := by rw [add_comm]; exact W.rw_complementary hv h0

end KirchbergRordam.GenericRW.OrderZero.WeightedUnits

namespace KirchbergRordam.GenericRW.OrderZero.WeightedUnits
variable {A : Type*} [CStarAlgebra A] [Nontrivial A] [PartialOrder A] [StarOrderedRing A]

def rwHom (W : WeightedUnits (Fin rankNum) A) {v : A}
    (hv : star v*v=1-W.h) (h0 : W.x 0 0*v=v) : DimensionDrop23 →⋆ₐ[ℂ] A :=
  (W.rwPair hv h0).dimensionDropHom
end KirchbergRordam.GenericRW.OrderZero.WeightedUnits
end

end OAI