import OAI.Analysis.InterpolatedFactors.PairedAbsorption

namespace OAI

noncomputable section

universe u_1 u_2 u_3 u_4 u_5 u_6

namespace FreeGroupFactorMain.WeightedFock
open FreeFock Amplification WeightedCornerIndex

def oldAnnihilators (u v : ℝ) : Submodule ℂ (PCorner ℕ) where
  carrier := {X | ∀ a : Base u v, star (X : Operator ℕ) ((a.val : Operator ℕ) (vacuum u v))=0}
  zero_mem' := by intro a; simp [star_zero (Operator ℕ)]
  add_mem' := by
    intro X Y hX hY a
    change star ((X : Operator ℕ)+(Y : Operator ℕ)) _=0
    rw [star_add (R := Operator ℕ),add_apply,hX a,hY a,add_zero]
  smul_mem' := by
    intro c X hX a
    change star (c • (X : Operator ℕ)) _=0
    rw [star_smul,smul_apply,hX a,smul_zero]

theorem oldAnnihilators_sandwich (u v : ℝ) (p q : Base u v) (X : PCorner ℕ)
    (hX : X∈oldAnnihilators u v) : (p:PCorner ℕ)*X*(q:PCorner ℕ)∈oldAnnihilators u v := by
  intro a
  change star ((p.val : Operator ℕ)*(X : Operator ℕ)*(q.val : Operator ℕ)) _=0
  rw [star_mul,star_mul,mul_apply_eq_comp,mul_apply_eq_comp]
  have hh := hX (star p*a)
  change star (X : Operator ℕ) (star (p.val : Operator ℕ) ((a.val : Operator ℕ) (vacuum u v)))=0 at hh
  rw [hh,map_zero]

theorem kindCreator_annihilator (u v : ℝ) (k : Kind) (hk : k.valid) :
    kindCreator u v k∈oldAnnihilators u v := by
  intro a
  cases k with
  | fresh n r s =>
    exact normalizedCreation_annihilate u v (0:ℕ) 1 (n+2)
      (by omega) (by omega) (by omega) r s (filledOfCorner a)
  | residual r s => exact normalizedResidual_annihilate u v (0:ℕ) 1 (by omega) r s hk (filledOfCorner a)
  | diagonal r => exact normalizedDiagonal_annihilate u v (0:ℕ) 1 0 (by omega) (by omega) r (filledOfCorner a)

theorem rawReservoir_annihilator (u v : ℝ) (i : WeightedCornerIndex.Index) (n : ℕ) :
    rawReservoir u v i n∈oldAnnihilators u v := by
  intro a
  exact normalizedCreation_annihilate u v (0:ℕ) 1 (reservoirCode (i,n)+2)
    (by omega) (by omega) (by omega) false false (filledOfCorner a)

theorem cornerAbsorption_annihilator (u v : ℝ) (hv : 0<v) (hvu : v<u)
    (i : WeightedCornerIndex.Index) (n : ℕ) :
    (cornerAbsorption u v hv hvu).output i n∈oldAnnihilators u v :=
  (cornerAbsorption u v hv hvu).output_mem (oldAnnihilators u v) (oldAnnihilators_sandwich u v)
    (fun i => kindCreator_annihilator u v _ (description_valid i)) (rawReservoir_annihilator u v) i n
end FreeGroupFactorMain.WeightedFock

namespace FreeGroupFactorMain.Amplification
variable {A : Type u_1} [CStarAlgebra A]

def cornerEqualityEquiv (p q : A) (hp : IsStarProjection p) (hq : IsStarProjection q) (h : p=q) :
    Corner p hp ≃⋆ₐ[ℂ] Corner q hq := by
  subst q
  exact StarAlgEquiv.refl ℂ (Corner p hp)

theorem cornerEqualityEquiv_val (p q : A) (hp : IsStarProjection p) (hq : IsStarProjection q) (h : p=q)
    (x : Corner p hp) : (cornerEqualityEquiv p q hp hq h x : A)=(x:A) := by
  subst q
  rfl

variable {E : Type u_2} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
variable (p : E →L[ℂ] E) (hp : IsStarProjection p) [CompleteSpace p.range]

include hp in
theorem projectionRange_starProjection : p.range.starProjection=p :=
  (isStarProjection_iff_eq_starProjection_range.mp hp).choose_spec.symm

def projectionRepresentation : Corner p hp ≃⋆ₐ[ℂ] (p.range →L[ℂ] p.range) :=
  (cornerEqualityEquiv p p.range.starProjection hp isStarProjection_starProjection
    (projectionRange_starProjection p hp).symm).trans (cornerRepresentation p.range)

theorem projectionRepresentation_apply (x : Corner p hp) (ξ : p.range) :
    (projectionRepresentation p hp x ξ : E)=(x:E →L[ℂ] E) ξ := by
  change (cornerRestrict p.range
    (cornerEqualityEquiv p p.range.starProjection hp isStarProjection_starProjection
      (projectionRange_starProjection p hp).symm x) ξ : E) = _
  rw [cornerRestrict_apply,cornerEqualityEquiv_val]
end FreeGroupFactorMain.Amplification

namespace FreeGroupFactorMain.WeightedFock

section
open FreeFock Amplification Filter Topology
open scoped ENNReal
variable {ι : Type u_3} [DecidableEq ι]

abbrev PRange (ι : Type u_4) [DecidableEq ι] := (P : Operator ι).range
instance pRange_complete : CompleteSpace (PRange ι) :=
  (ContinuousLinearMap.IsIdempotentElem.isClosed_range
    (projection_P (ι := ι)).isIdempotentElem).completeSpace_coe

def pRoot : PRange ι := ⟨lp.single 2 ([],true) 1,⟨lp.single 2 ([],true) 1,P_nil_true 1⟩⟩

theorem pRoot_norm : ‖(pRoot : PRange ι)‖=1 := by
  change ‖lp.single (E := fun _ : Path ι => ℂ) 2 ([],true) 1‖=1
  rw [lp.norm_single] <;> norm_num

instance pRange_nontrivial : Nontrivial (PRange ι) := by
  apply nontrivial_of_ne (pRoot : PRange ι) 0
  intro h
  have hh := pRoot_norm (ι := ι)
  rw [h,norm_zero] at hh
  exact zero_ne_one hh

abbrev pRepresentation : PCorner ι ≃⋆ₐ[ℂ] (PRange ι →L[ℂ] PRange ι) :=
  projectionRepresentation P projection_P

theorem pRepresentation_apply (x : PCorner ι) (ξ : PRange ι) :
    (pRepresentation x ξ : H ι)=(x:Operator ι) ξ :=
  projectionRepresentation_apply P projection_P x ξ

def pProject : H ι →L[ℂ] PRange ι := (P : Operator ι).range.orthogonalProjectionOnto

theorem pProject_val (ξ : H ι) : (pProject ξ : H ι)=P ξ := by
  change (P : Operator ι).range.starProjection ξ=P ξ
  rw [projectionRange_starProjection P projection_P]

theorem pProject_coe (ξ : PRange ι) : pProject (ξ:H ι)=ξ :=
  Submodule.orthogonalProjectionOnto_mem_subspace_eq_self ξ

theorem pRange_total (K : Submodule ℂ (PRange ι)) (hK : IsClosed (K : Set (PRange ι)))
    (hb : ∀ w : Path ι, pProject (lp.single 2 w 1)∈K) : K=⊤ := by
  apply top_unique
  intro ξ _
  have hs := (lp.hasSum_single (by norm_num : (2:ℝ≥0∞)≠⊤) (ξ:H ι)).map pProject pProject.continuous
  rw [pProject_coe] at hs
  apply hK.mem_of_tendsto hs
  filter_upwards [] with s
  apply K.sum_mem
  intro w _
  have he : lp.single (E := fun _ : Path ι => ℂ) 2 w ((ξ:H ι) w)=
      ((ξ:H ι) w) • lp.single 2 w 1 := by
    ext q
    simp [lp.single_apply,Pi.single_apply]
  change pProject (lp.single 2 w ((ξ:H ι) w))∈K
  rw [he,map_smul]
  exact K.smul_mem _ (hb w)

def oldBaseCorner (u v : ℝ) (i j : ι) : PCorner ι :=
  ⟨oldBaseGenerator u v i j,oldBaseGenerator_left u v i j,oldBaseGenerator_right u v i j⟩

def oldBaseOp (u v : ℝ) (i j : ι) : PRange ι →L[ℂ] PRange ι := pRepresentation (oldBaseCorner u v i j)

theorem oldBaseCorner_selfAdjoint (u v : ℝ) (i j : ι) : IsSelfAdjoint (oldBaseCorner u v i j) :=
  Subtype.ext (oldBaseGenerator_selfAdjoint u v i j).star_eq

theorem oldBaseOp_selfAdjoint (u v : ℝ) (i j : ι) : IsSelfAdjoint (oldBaseOp u v i j) :=
by
  change star (pRepresentation (oldBaseCorner u v i j))=pRepresentation (oldBaseCorner u v i j)
  exact ((pRepresentation (ι := ι)).map_star' (oldBaseCorner u v i j)).symm.trans
    (congrArg (fun x : PCorner ι => pRepresentation x) (oldBaseCorner_selfAdjoint u v i j).star_eq)

theorem oldBaseOp_eigen_root_zero (u v : ℝ) (hv : 0<v) (hvu : v<u) (i j : ι)
    (z : ℂ) (η : PRange ι) (he : oldBaseOp u v i j η=z • η) : inner ℂ (pRoot : PRange ι) η=0 := by
  have hh := congrArg (fun x : PRange ι => (x:H ι)) he
  rw [oldBaseOp,pRepresentation_apply] at hh
  have hz := oldBaseGenerator_eigen_root_zero u v hv hvu i j z (η:H ι) hh
  change inner ℂ (lp.single 2 ([],true) 1) (η:H ι)=0
  simpa only [lp.inner_single_left,RCLike.inner_apply,map_one,mul_one] using hz
end

open FreeFock Amplification
variable {ι : Type u_5} [DecidableEq ι]

def pSandwich (B : Operator ι) : PCorner ι :=
  ⟨P*B*P,by
    constructor
    · rw [← mul_assoc,← mul_assoc,projection_P.isIdempotentElem.eq]
    · rw [mul_assoc,mul_assoc,projection_P.isIdempotentElem.eq,mul_assoc]⟩

theorem pSandwich_commute (B : Operator ι) (hBP : Commute P B)
    (x : PCorner ι) (hBx : Commute (x:Operator ι) B) : Commute (pSandwich B) x := by
  apply Subtype.ext
  change P*B*P*(x:Operator ι)=(x:Operator ι)*(P*B*P)
  calc
    _ = P*(B*(x:Operator ι)) := by rw [mul_assoc (P*B),x.property.1,mul_assoc]
    _ = P*((x:Operator ι)*B) := by rw [hBx.eq]
    _ = (x:Operator ι)*B := by rw [← mul_assoc,x.property.1]
    _ = (x:Operator ι)*(P*B*P) := by
      symm
      rw [← mul_assoc,← mul_assoc,x.property.2,mul_assoc,← hBP.eq,← mul_assoc,x.property.2]

theorem pRoot_vacuum (u v : ℝ) : (P : Operator ι) (vacuum u v)=(u:ℂ) • ((pRoot : PRange ι):H ι) := by
  simp only [vacuum,map_add,map_smul,P_nil_true,P_nil_false,smul_zero,add_zero,pRoot]

theorem pSandwich_basis (u v : ℝ) (w : Path ι) (B : Operator ι)
    (hBP : Commute P B) (hB : B (vacuum u v)=lp.single 2 w 1) :
    (u:ℂ) • pRepresentation (pSandwich B) pRoot=pProject (lp.single 2 w 1) := by
  apply Subtype.ext
  change (u:ℂ) • (pRepresentation (pSandwich B) pRoot : H ι)=_
  rw [pRepresentation_apply,pProject_val,← hB]
  change (u:ℂ) • ((P*B*P : Operator ι) ((pRoot : PRange ι):H ι))=P (B (vacuum u v))
  rw [← map_smul,← pRoot_vacuum]
  have he : P*B*P*P=P*B := by
    rw [mul_assoc (P*B),projection_P.isIdempotentElem.eq,mul_assoc,← hBP.eq,
      ← mul_assoc,projection_P.isIdempotentElem.eq]
  exact DFunLike.congr_fun he (vacuum u v)

theorem centralizer_bicommutant {E : Type u_6} [Ring E] [StarRing E] [Algebra ℂ E] [StarModule ℂ E]
    (S : Set E) (B : StarSubalgebra.centralizer ℂ S) :
    (B:E)∈StarSubalgebra.centralizer ℂ (Bicommutant.algebra S : Set E) := by
  rw [StarSubalgebra.mem_centralizer_iff]
  intro T hT
  exact ⟨((StarSubalgebra.mem_centralizer_iff ℂ).mp hT B B.property).1.symm,
    ((StarSubalgebra.mem_centralizer_iff ℂ).mp (star_mem hT) B B.property).1.symm⟩

theorem oldBaseOp_commutant_total (u v : ℝ) (hu : u≠0) (hv : v≠0) (i j : ι) :
    (Submodule.span ℂ (Set.range (fun B : StarSubalgebra.centralizer ℂ
      (Bicommutant.algebra ({oldBaseOp u v i j} : Set (PRange ι →L[ℂ] PRange ι)) :
        Set (PRange ι →L[ℂ] PRange ι)) => (B:PRange ι →L[ℂ] PRange ι) pRoot))).topologicalClosure=⊤ := by
  let N := StarSubalgebra.centralizer ℂ
    (Bicommutant.algebra ({oldBaseOp u v i j} : Set (PRange ι →L[ℂ] PRange ι)) :
      Set (PRange ι →L[ℂ] PRange ι))
  let K := (Submodule.span ℂ (Set.range (fun B : N => (B:PRange ι →L[ℂ] PRange ι) pRoot))).topologicalClosure
  apply pRange_total K (Submodule.isClosed_topologicalClosure _)
  intro w
  obtain ⟨B,hB,heB,_⟩ := good_right_basis u v hu hv w
  have hBP : Commute P B := ((StarSubalgebra.mem_centralizer_iff ℂ).mp hB P (Set.mem_insert _ _)).1
  have hBA : Commute (oldBaseGenerator u v i j) B :=
    ((StarSubalgebra.mem_centralizer_iff ℂ).mp (oldBaseGenerator_mem_ambient u v hu i j) B hB).1.symm
  have hc : Commute (pRepresentation (pSandwich B)) (pRepresentation (oldBaseCorner u v i j)) := by
    change _ * _ = _ * _
    simpa only [map_mul] using congrArg (fun x : PCorner ι => pRepresentation x)
      (pSandwich_commute B hBP (oldBaseCorner u v i j) hBA).eq
  have hm : pRepresentation (pSandwich B)∈N := by
    apply centralizer_bicommutant ({oldBaseOp u v i j} : Set (PRange ι →L[ℂ] PRange ι))
      ⟨pRepresentation (pSandwich B),?_⟩
    rw [StarSubalgebra.mem_centralizer_iff]
    intro T hT
    rcases hT with rfl
    exact ⟨hc.symm,(by rw [(oldBaseOp_selfAdjoint u v i j).star_eq]; exact hc.symm)⟩
  rw [← pSandwich_basis u v w B hBP heB]
  exact K.smul_mem _ (Submodule.le_topologicalClosure _
    (Submodule.subset_span (Set.mem_range_self (⟨pRepresentation (pSandwich B),hm⟩:N))))
end FreeGroupFactorMain.WeightedFock

end

end OAI