import OAI.Analysis.InterpolatedFactors.Recognition

namespace OAI

noncomputable section

universe u_1 u_2 u_3 u_4 u_5 u_6

section
namespace FreeGroupFactorMain.CornerRerouting
variable {A : Type u_1} [Ring A] [StarRing A] [Algebra ℂ A] [StarModule ℂ A]

theorem filled_edge_corner_generated {p v x d a : A}
    (hp : IsStarProjection p) (hpv : p*v=v) (hvr : v*(1-p)=v)
    (hvi : star v*v=1-p) (hpx : p*x=x) (hxr : x*(1-p)=x)
    (hf : IsSelfAdjoint (x*star v)) (hd : IsSelfAdjoint d) (hds : Supported p d)
    (ha : a∈Bicommutant.algebra (insert d (Bicommutant.algebra (insert p {x+star x}) : Set A)))
    (has : Supported p a) :
    a∈Bicommutant.algebra (insert p (insert (v*star v) (insert (x*star v) {d}))) := by
  have hvp := right_zero hvr
  have hvsp : star v*p=star v := by
    simpa only [star_mul,hp.isSelfAdjoint.star_eq] using congrArg star hpv
  have hfs : Supported p (x*star v) :=
    ⟨by rw [← mul_assoc,hpx],by rw [mul_assoc,hvsp]⟩
  have hrs : Supported p (v*star v) :=
    ⟨by rw [← mul_assoc,hpv],by rw [mul_assoc,hvsp]⟩
  have htest (t : A) (ht : t∈StarSubalgebra.centralizer ℂ
      (insert p (insert (v*star v) (insert (x*star v) {d})))) : Commute t a := by
    have hc := (StarSubalgebra.mem_centralizer_iff ℂ).mp ht
    have htp : Commute p t := (hc _ (Set.mem_insert _ _)).1
    have htr : Commute (v*star v) t := (hc _ (Set.mem_insert_of_mem _ (Set.mem_insert _ _))).1
    have htf : Commute (x*star v) t :=
      (hc _ (Set.mem_insert_of_mem _ (Set.mem_insert_of_mem _ (Set.mem_insert _ _)))).1
    have htd : Commute d t :=
      (hc _ (Set.mem_insert_of_mem _ (Set.mem_insert_of_mem _ (Set.mem_insert_of_mem _ (Set.mem_singleton _))))).1
    have hts : Supported p (p*t*p) :=
      ⟨by rw [← mul_assoc,← mul_assoc,hp.isIdempotentElem.eq],by rw [mul_assoc,hp.isIdempotentElem.eq]⟩
    have hcs (z : A) (hz : Supported p z) (hzt : Commute z t) : Commute (p*t*p) z := by
      have hpz : Commute p z := hz.1.trans hz.2.symm
      exact (hpz.mul_left hzt.symm).mul_left hpz
    have hLP : Commute (lift v (p*t*p)) p :=
      lift_commute_supported hp.isSelfAdjoint hvp ⟨hp.isIdempotentElem.eq,hp.isIdempotentElem.eq⟩
        (hts.2.trans hts.1.symm)
    have hLV := lift_commute_edge hpv hvp hvi hvr hts (hcs _ hrs htr)
    have hLVS := lift_commute_edge_star hp.isSelfAdjoint hpv hvp hvi hvr hts (hcs _ hrs htr)
    have hLF := lift_commute_supported hp.isSelfAdjoint hvp hfs (hcs _ hfs htf)
    have hx : x=(x*star v)*v := by rw [mul_assoc,hvi,hxr]
    have hLX : Commute (lift v (p*t*p)) x := by
      rw [hx]
      exact hLF.mul_right hLV
    have hLXS : Commute (lift v (p*t*p)) (star x) := by
      rw [hx,star_mul,hf.star_eq]
      exact hLVS.mul_right hLF
    have hLO : lift v (p*t*p)∈StarSubalgebra.centralizer ℂ (insert p {x+star x}) := by
      rw [StarSubalgebra.mem_centralizer_iff]
      rintro y (rfl|hy)
      · exact ⟨hLP.symm.eq,by rw [hp.isSelfAdjoint.star_eq];exact hLP.symm.eq⟩
      · rcases hy with rfl
        exact ⟨(hLX.add_right hLXS).symm.eq,by
          rw [star_add,star_star,add_comm (star x) x];exact (hLX.add_right hLXS).symm.eq⟩
    have hLD : Commute (lift v (p*t*p)) d :=
      lift_commute_supported hp.isSelfAdjoint hvp hds (hcs _ hds htd)
    have hL : lift v (p*t*p)∈StarSubalgebra.centralizer ℂ
        (insert d (Bicommutant.algebra (insert p {x+star x}) : Set A)) := by
      rw [StarSubalgebra.mem_centralizer_iff]
      rintro y (rfl|hy)
      · exact ⟨hLD.symm.eq,by rw [hd.star_eq];exact hLD.symm.eq⟩
      · exact ⟨((StarSubalgebra.mem_centralizer_iff ℂ).mp hy _ hLO).1.symm,
          ((StarSubalgebra.mem_centralizer_iff ℂ).mp (star_mem hy) _ hLO).1.symm⟩
    have he := ((StarSubalgebra.mem_centralizer_iff ℂ).mp ha _ hL).1
    rw [lift_mul_supported hvp has,supported_mul_lift hp.isSelfAdjoint hvp has] at he
    have htc : p*t*p=t*p := by rw [htp.eq,mul_assoc,hp.isIdempotentElem.eq]
    change t*a=a*t
    calc
      t*a=(t*p)*a := by rw [mul_assoc,has.1]
      _ = (p*t*p)*a := by rw [htc]
      _ = a*(p*t*p) := he
      _ = a*(t*p) := by rw [htc]
      _ = (a*p)*t := by rw [← htp.eq,mul_assoc]
      _ = a*t := by rw [has.2]
  rw [Bicommutant.algebra,StarSubalgebra.mem_centralizer_iff]
  intro t ht
  exact ⟨(htest t ht).eq,(htest (star t) (star_mem ht)).eq⟩
end FreeGroupFactorMain.CornerRerouting

namespace FreeGroupFactorMain.WeightedFock
open FreeFock
variable {ι : Type u_2} [DecidableEq ι]

theorem weightedDefect_semicircle_eq (u v : ℝ) (i j : ι) :
    weightedDefectCreation u v i j+star (weightedDefectCreation u v i j)=
      (u:ℂ) • defectSemicircle u v i j := by
  simp only [weightedDefectCreation_eq,star_smul,Complex.star_def,Complex.conj_ofReal,
    defectSemicircle,smul_add]

theorem filled_corner_mem_diffuseBase (u v : ℝ) (hv : 0<v) (hvu : v<u) (i j : ι)
    (a : filledEdgeAlgebra u v i j) (ha : CornerRerouting.Supported P (a : Operator ι)) :
    (a : Operator ι)∈diffuseBase u v i j := by
  have hds : CornerRerouting.Supported P
      (weightedDefectCreation u v i j+star (weightedDefectCreation u v i j)) := by
    rw [weightedDefect_semicircle_eq]
    exact ⟨by rw [mul_smul_comm,P_mul_defectSemicircle],
      by rw [smul_mul_assoc,defectSemicircle_mul_P]⟩
  have hh := CornerRerouting.filled_edge_corner_generated projection_P
    (edgePolar_left u v i) (edgePolar_right u v i) (edgePolar_initial u v hv.le hvu i)
    (offDiagonal_left u v i) (offDiagonal_right u v i) (leftModulus_selfAdjoint u v i)
    (IsSelfAdjoint.add_star_self (weightedDefectCreation u v i j)) hds a.property ha
  apply Bicommutant.generated_le (insert P {oldBaseGenerator u v i j})
    (insert P (insert (edgeRange u v i) (insert (leftModulus u v i)
      {weightedDefectCreation u v i j+star (weightedDefectCreation u v i j)}))) ?_ hh
  intro x hx
  rcases hx with rfl|hx
  · exact P_mem_diffuseBase u v i j
  rcases hx with rfl|hx
  · exact edgeRange_mem_diffuseBase u v hv hvu i j
  rcases hx with rfl|hx
  · exact leftModulus_mem_diffuseBase u v hv hvu i j
  rcases hx with rfl
  rw [weightedDefect_semicircle_eq]
  exact (diffuseBase u v i j).smul_mem (defectSemicircle_mem_diffuseBase u v hv hvu i j) _
end FreeGroupFactorMain.WeightedFock

end

namespace FreeGroupFactorMain.WeightedFock

section
open FreeFock Amplification CyclicSpectral
variable {ι : Type u_3} [DecidableEq ι]

theorem pRepresentation_mem_bicommutant (u v : ℝ) (i j : ι) (x : PCorner ι)
    (hx : (x:Operator ι)∈diffuseBase u v i j) :
    pRepresentation x∈Bicommutant.algebra ({oldBaseOp u v i j} : Set (PRange ι →L[ℂ] PRange ι)) := by
  have hmul (a b : PCorner ι) : pRepresentation (a*b)=pRepresentation a*pRepresentation b :=
    (pRepresentation (ι := ι)).map_mul' a b
  have htest (B : PRange ι →L[ℂ] PRange ι)
      (hB : B∈StarSubalgebra.centralizer ℂ ({oldBaseOp u v i j} : Set (PRange ι →L[ℂ] PRange ι))) :
      B*pRepresentation x=pRepresentation x*B := by
    let b := (pRepresentation (ι := ι)).symm B
    have hbA : Commute (oldBaseCorner u v i j) b := by
      apply (pRepresentation (ι := ι)).injective
      change pRepresentation (oldBaseCorner u v i j*b)=pRepresentation (b*oldBaseCorner u v i j)
      rw [hmul,hmul]
      simpa only [StarAlgEquiv.apply_symm_apply,oldBaseOp,b] using
        ((StarSubalgebra.mem_centralizer_iff ℂ).mp hB _ (Set.mem_singleton _)).1
    have hb : (b:Operator ι)∈StarSubalgebra.centralizer ℂ (insert P {oldBaseGenerator u v i j}) := by
      rw [StarSubalgebra.mem_centralizer_iff]
      rintro T (rfl|hT)
      · exact ⟨b.property.1.trans b.property.2.symm,by
          rw [projection_P.isSelfAdjoint.star_eq];exact b.property.1.trans b.property.2.symm⟩
      · rcases hT with rfl
        have hh : oldBaseGenerator u v i j*(b:Operator ι)=(b:Operator ι)*oldBaseGenerator u v i j :=
          congrArg (fun z : PCorner ι => (z:Operator ι)) hbA.eq
        exact ⟨hh,by rw [(oldBaseGenerator_selfAdjoint u v i j).star_eq];exact hh⟩
    have hh : b*x=x*b := Subtype.ext (((StarSubalgebra.mem_centralizer_iff ℂ).mp hx _ hb).1)
    have he := congrArg (fun z : PCorner ι => pRepresentation z) hh
    rw [hmul,hmul] at he
    simpa only [StarAlgEquiv.apply_symm_apply,b] using he
  rw [Bicommutant.algebra,StarSubalgebra.mem_centralizer_iff]
  intro B hB
  exact ⟨htest B hB,htest (star B) (star_mem hB)⟩

variable (u v : ℝ) (hv : 0<v) (hvu : v<u)

theorem representedBase_le_oldBase (hv : 0<v) (hvu : v<u) : representedBase u v ≤
    Bicommutant.algebra ({oldBaseOp u v (0:ℕ) 1} : Set (PRange ℕ →L[ℂ] PRange ℕ)) := by
  intro T hT
  have hh := filled_corner_mem_diffuseBase u v hv hvu (0:ℕ) 1
    (filledOfCorner ⟨(pRepresentation (ι := ℕ)).symm T,hT⟩)
    ((pRepresentation (ι := ℕ)).symm T).property
  simpa only [StarAlgEquiv.apply_symm_apply] using
    pRepresentation_mem_bicommutant u v (0:ℕ) 1 ((pRepresentation (ι := ℕ)).symm T) hh

theorem oldBaseOp_mem_weightedUniform : oldBaseOp u v (0:ℕ) 1∈
    Bicommutant.algebra (Set.range (weightedUniform u v hv hvu)) := by
  let : NormedRing (PRange ℕ →L[ℂ] PRange ℕ) := ContinuousLinearMap.toNormedRing
  let := oldBaseOp_noAtoms u v hv hvu
  have h := operator_mem_haar_bicommutant (oldBaseOp u v (0:ℕ) 1)
    (oldBaseOp_selfAdjoint u v 0 1) pRoot
    (Bicommutant.algebra ({oldBaseOp u v (0:ℕ) 1} : Set (PRange ℕ →L[ℂ] PRange ℕ)))
    (Set.isClosed_centralizer _)
    (Bicommutant.subset _ (Set.mem_singleton _))
    (oldBaseOp_commutant_total u v (hv.trans hvu).ne' hv.ne' (0:ℕ) 1)
  apply Bicommutant.mono _ (Set.range (weightedUniform u v hv hvu)) ?_ h
  intro T hT
  rcases hT with rfl
  exact ⟨uniformPhase,(uniformHom_phase (oldBaseOp u v (0:ℕ) 1)
    (oldBaseOp_selfAdjoint u v 0 1) pRoot).symm⟩

theorem representedBase_le_weightedUniform : representedBase u v ≤
    Bicommutant.algebra (Set.range (weightedUniform u v hv hvu)) := by
  apply (representedBase_le_oldBase u v hv hvu).trans
  apply Bicommutant.generated_le
  intro T hT
  rcases hT with rfl
  exact oldBaseOp_mem_weightedUniform u v hv hvu
end

section
open FreeFock Amplification WeightedCornerIndex
variable (u v : ℝ) (hv : 0<v) (hvu : v<u)

theorem absorbed_kind_recovery (M : StarSubalgebra ℂ (PCorner ℕ))
    (hbase : ∀ a : Base u v,(a:PCorner ℕ)∈M)
    (hout : ∀ i n,(cornerAbsorption u v hv hvu).output i n+
      star ((cornerAbsorption u v hv hvu).output (CircularRotation.flip i) n)∈M)
    (k : Kind) (hk : k.valid) : kindCreator u v k+star (kindCreator u v k.transpose)∈M := by
  have hh := ((cornerAbsorption u v hv hvu).output_generation M
    (fun i => hbase (kindLeft u v (description i)))
    (fun i => hbase (kindRight u v (description i)))).mpr hout
  have he := hh.1 (indexOf k)
  change kindCreator u v (description (indexOf k))+
    star (kindCreator u v (description (CircularRotation.flip (indexOf k))))∈M at he
  simpa only [description_flip,description_indexOf k hk] using he

theorem absorbed_raw_recovery (M : StarSubalgebra ℂ (PCorner ℕ))
    (hbase : ∀ a : Base u v,(a:PCorner ℕ)∈M)
    (hout : ∀ i n,(cornerAbsorption u v hv hvu).output i n+
      star ((cornerAbsorption u v hv hvu).output (CircularRotation.flip i) n)∈M)
    (n : ℕ) : pFresh u v 0 (n+2) false false+star (pFresh u v 0 (n+2) false false)∈M := by
  have hh := ((cornerAbsorption u v hv hvu).output_generation M
    (fun i => hbase (kindLeft u v (description i)))
    (fun i => hbase (kindRight u v (description i)))).mpr hout
  obtain ⟨⟨i,m⟩,h⟩ := reservoirCode.surjective n
  simpa only [cornerAbsorption,rawReservoir,h] using hh.2 i m

theorem absorbed_fresh_recovery (M : StarSubalgebra ℂ (PCorner ℕ))
    (hbase : ∀ a : Base u v,(a:PCorner ℕ)∈M)
    (hout : ∀ i n,(cornerAbsorption u v hv hvu).output i n+
      star ((cornerAbsorption u v hv hvu).output (CircularRotation.flip i) n)∈M)
    (n : ℕ) (r s : Bool) : pFresh u v 0 (n+2) r s+star (pFresh u v 0 (n+2) s r)∈M := by
  by_cases hh : r=false ∧ s=false
  · rcases hh with ⟨rfl,rfl⟩
    exact absorbed_raw_recovery u v hv hvu M hbase hout n
  · exact absorbed_kind_recovery u v hv hvu M hbase hout (.fresh n r s) hh

variable {ι : Type u_4} [DecidableEq ι]

theorem vertex_C_vertex (i : ι) (r : Bool) :
    vertex r*C u v i*vertex r=(weight u v r:ℂ) • edgeCreation i r r := by
  cases r
  · simp only [vertex,Bool.false_eq_true,ite_false,C,sub_mul,one_mul,mul_add,mul_smul_comm,
      P_creation_true,P_creation_false,sub_self,smul_zero,sub_zero,zero_add,
      smul_mul_assoc,weight,edgeCreation]
  · simp only [vertex,ite_true,C,mul_add,mul_smul_comm,P_creation_true,
      P_creation_false,smul_zero (M := ℂ) (A := Operator ι),add_zero,smul_mul_assoc,weight,edgeCreation]

theorem pDiagonal_eq_pFresh (i : ι) (r : Bool) :
    pDiagonal u v i i r=pFresh u v i i r r := by
  apply Subtype.ext
  change ((weight u v (!r):ℂ)/(u:ℂ)) •
    (supportedLeg u v i r*edgeCreation i (!r) (!r)*star (supportedLeg u v i r))=
      (u:ℂ)⁻¹ • (supportedLeg u v i r*C u v i*star (supportedLeg u v i r))
  have hh : supportedLeg u v i r*C u v i*star (supportedLeg u v i r)=
      (weight u v (!r):ℂ) •
        (supportedLeg u v i r*edgeCreation i (!r) (!r)*star (supportedLeg u v i r)) := by
    calc
      _ = supportedLeg u v i r*(vertex (!r)*C u v i*vertex (!r))*star (supportedLeg u v i r) := by
        simp only [← mul_assoc,supportedLeg_vertex]
        rw [mul_assoc _ (vertex (!r)),vertex_star_supportedLeg]
      _ = _ := by rw [vertex_C_vertex];simp only [mul_smul_comm,smul_mul_assoc]
  rw [hh,smul_smul]
  congr 1
  exact div_eq_inv_mul _ _
end

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

def blockCorner (u v : ℝ) (i j : ι) (r s : Bool) : PCorner ι :=
  sandwiched P projection_P (supportedLeg u v i r) (supportedLeg u v i s) (S u v j)
    (P_mul_supportedLeg u v i r) (P_mul_supportedLeg u v i s)

theorem blockCorner_normalized (u v : ℝ) (hu : u≠0) (i j : ι) (r s : Bool) :
    blockCorner u v i j r s=(u:ℂ) • (pFresh u v i j r s+star (pFresh u v i j s r)) := by
  apply Subtype.ext
  change supportedLeg u v i r*S u v j*star (supportedLeg u v i s)=
    (u:ℂ) • (normalizedCreation u v i j r s+star (normalizedCreation u v i j s r))
  simp only [normalizedCreation,star_smul,Complex.star_def,map_inv₀,Complex.conj_ofReal,
    ← smul_add (M := ℂ) (A := Operator ι)]
  rw [smul_smul,mul_inv_cancel₀ (Complex.ofReal_ne_zero.mpr hu),one_smul,supportedCreation_paired]

def residualBlockCorner (u v : ℝ) (i j : ι) (r s : Option Bool) : PCorner ι :=
  sandwiched P projection_P (residualLeg u v i r) (residualLeg u v i s) (S u v j)
    (P_mul_residualLeg u v i r) (P_mul_residualLeg u v i s)

theorem residualBlockCorner_normalized (u v : ℝ) (hu : u≠0) (i j : ι) (r s : Option Bool) :
    residualBlockCorner u v i j r s=(u:ℂ) • (pResidual u v i j r s+star (pResidual u v i j s r)) := by
  apply Subtype.ext
  change residualLeg u v i r*S u v j*star (residualLeg u v i s)=
    (u:ℂ) • (normalizedResidual u v i j r s+star (normalizedResidual u v i j s r))
  simp only [normalizedResidual,star_smul,Complex.star_def,map_inv₀,Complex.conj_ofReal,
    ← smul_add (M := ℂ) (A := Operator ι)]
  rw [smul_smul,mul_inv_cancel₀ (Complex.ofReal_ne_zero.mpr hu),one_smul]
  exact (residualPair_eq u v i j r s).symm

theorem blockCorner_zero_off (u v : ℝ) (i : ι) :
    (blockCorner u v i i false true : Operator ι)=leftModulus u v i := by
  change P*S u v i*star (edgePolar u v i)=_
  have h : (1-P)*star (edgePolar u v i)=star (edgePolar u v i) := by
    simpa only [star_mul,star_sub (R := Operator ι),star_one,projection_P.isSelfAdjoint.star_eq]
      using congrArg star (edgePolar_right u v i)
  rw [leftModulus,offDiagonal, mul_assoc _ (1-P),h]

theorem blockCorner_star (u v : ℝ) (i j : ι) (r s : Bool) :
    star (blockCorner u v i j r s)=blockCorner u v i j s r := by
  apply Subtype.ext
  change star (supportedLeg u v i r*S u v j*star (supportedLeg u v i s))=_
  simp only [star_mul,star_star,(S_selfAdjoint u v j).star_eq,mul_assoc]
  rfl

variable (u v : ℝ) (hv : 0<v) (hvu : v<u)
variable (M : StarSubalgebra ℂ (PCorner ℕ))
    (hbase : ∀ a : Base u v,(a:PCorner ℕ)∈M)
    (hout : ∀ i n,(cornerAbsorption u v hv hvu).output i n+
      star ((cornerAbsorption u v hv hvu).output (CircularRotation.flip i) n)∈M)

include hbase in
theorem old_off_block_mem : blockCorner u v (0:ℕ) 0 false true∈M := by
  apply hbase ⟨blockCorner u v 0 0 false true,?_⟩
  change (blockCorner u v 0 0 false true : Operator ℕ)∈filledEdgeAlgebra u v 0 1
  rw [blockCorner_zero_off]
  exact edgeAlgebra_le_filled u v 0 1
    (mul_mem (offDiagonal_mem_edge u v 0) (star_mem (edgePolar_mem_edge u v 0)))

include hout hbase in
theorem absorbed_old_block_recovery (r s : Bool) : blockCorner u v 0 0 r s∈M := by
  have hu : u≠0 := (hv.trans hvu).ne'
  cases r <;> cases s
  · rw [blockCorner_normalized u v hu,← pDiagonal_eq_pFresh]
    exact M.smul_mem (absorbed_kind_recovery u v hv hvu M hbase hout (.diagonal false) trivial) _
  · exact old_off_block_mem u v M hbase
  · rw [← blockCorner_star u v 0 0 false true]
    exact star_mem (old_off_block_mem u v M hbase)
  · rw [blockCorner_normalized u v hu,← pDiagonal_eq_pFresh]
    exact M.smul_mem (absorbed_kind_recovery u v hv hvu M hbase hout (.diagonal true) trivial) _

include hbase hout in
theorem absorbed_residual_block_recovery (a b : Option Bool) :
    residualBlockCorner u v (0:ℕ) 1 a b∈M := by
  have hu : u≠0 := (hv.trans hvu).ne'
  by_cases hab : a=none ∧ b=none
  · rcases hab with ⟨rfl,rfl⟩
    apply hbase ⟨residualBlockCorner u v 0 1 none none,?_⟩
    change residualLeg u v (0:ℕ) none*S u v 1*star (residualLeg u v 0 none)∈filledEdgeAlgebra u v 0 1
    rw [← residualPair_eq,residualPair_none_none]
    exact (filledEdgeAlgebra u v 0 1).smul_mem (defectSemicircle_mem_filled u v hu 0 1) _
  · rw [residualBlockCorner_normalized u v hu]
    exact M.smul_mem (absorbed_kind_recovery u v hv hvu M hbase hout (.residual a b) hab) _

omit hv hvu M hbase hout in
theorem blockCorner_split_false_false : blockCorner u v (0:ℕ) 1 false false=
    residualBlockCorner u v 0 1 none none+residualBlockCorner u v 0 1 (some false) none+
    (residualBlockCorner u v 0 1 none (some false)+residualBlockCorner u v 0 1 (some false) (some false)) := by
  apply Subtype.ext
  change P*S u v 1*star P=_
  simp only [AddMemClass.coe_add,residualBlockCorner,sandwiched]
  rw [← residualLeg_sum u v (0:ℕ)]
  simp only [star_add (R := Operator ℕ),mul_add,add_mul]

omit hv hvu M hbase hout in
theorem blockCorner_split_false_true : blockCorner u v (0:ℕ) 1 false true=
    residualBlockCorner u v 0 1 none (some true)+residualBlockCorner u v 0 1 (some false) (some true) := by
  apply Subtype.ext
  change P*S u v 1*star (residualLeg u v 0 (some true))=_
  simp only [AddMemClass.coe_add,residualBlockCorner,sandwiched]
  rw [← residualLeg_sum u v (0:ℕ)]
  simp only [add_mul]

omit hv hvu M hbase hout in
theorem blockCorner_split_true_false : blockCorner u v (0:ℕ) 1 true false=
    residualBlockCorner u v 0 1 (some true) none+residualBlockCorner u v 0 1 (some true) (some false) := by
  apply Subtype.ext
  change residualLeg u v 0 (some true)*S u v 1*star P=_
  simp only [AddMemClass.coe_add,residualBlockCorner,sandwiched]
  rw [← residualLeg_sum u v (0:ℕ)]
  simp only [star_add (R := Operator ℕ),mul_add]

include hout hbase in
theorem absorbed_filled_block_recovery (r s : Bool) : blockCorner u v 0 1 r s∈M := by
  have hres := absorbed_residual_block_recovery u v hv hvu M hbase hout
  cases r <;> cases s
  · rw [blockCorner_split_false_false]
    exact add_mem (add_mem (hres _ _) (hres _ _)) (add_mem (hres _ _) (hres _ _))
  · rw [blockCorner_split_false_true];exact add_mem (hres _ _) (hres _ _)
  · rw [blockCorner_split_true_false];exact add_mem (hres _ _) (hres _ _)
  · exact hres (some true) (some true)

include hout hbase in
theorem absorbed_block_recovery (j : ℕ) (r s : Bool) : blockCorner u v 0 j r s∈M := by
  rcases j with _|(_|n)
  · exact absorbed_old_block_recovery u v hv hvu M hbase hout r s
  · exact absorbed_filled_block_recovery u v hv hvu M hbase hout r s
  · rw [blockCorner_normalized u v (hv.trans hvu).ne']
    exact M.smul_mem (absorbed_fresh_recovery u v hv hvu M hbase hout n r s) _
end

open FreeFock Amplification WeightedCornerIndex GaussianRecognition
variable {ι : Type u_6} [DecidableEq ι]

 theorem full_corner_commutant (u v : ℝ) (hv : 0<v) (hvu : v<u) (i₀ : ι)
    (X T : Operator ι) (hX : X ∈ ambientAlgebra u v)
    (hXs : CornerRerouting.Supported P X) (hT : CornerRerouting.Supported P T)
    (hR : Commute T (edgeRange u v i₀))
    (hA : ∀ i, Commute T (CornerRerouting.diagonal P (S u v i)))
    (hB : ∀ i, Commute T (CornerRerouting.offDiagonal P (edgePolar u v i₀) (S u v i)))
    (hBs : ∀ i, Commute T (star (CornerRerouting.offDiagonal P (edgePolar u v i₀) (S u v i))))
    (hC : ∀ i, Commute T (CornerRerouting.remaining P (edgePolar u v i₀) (S u v i))) :
    Commute T X :=
  CornerRerouting.corner_bicommutant projection_P (edgePolar_left u v i₀)
    (edgePolar_right u v i₀) (edgePolar_initial u v hv.le hvu i₀)
    hX hXs hT (S_selfAdjoint u v) hR hA hB hBs hC

def pAmbient (u v : ℝ) : StarSubalgebra ℂ (PCorner ι) :=
  subalgebraCorner (ambientAlgebra u v) P projection_P (P_mem_ambient u v)

theorem blockCorner_diagonal (u v : ℝ) (i j : ι) :
    (blockCorner u v i j false false : Operator ι)=CornerRerouting.diagonal P (S u v j) := by
  change P*S u v j*star P=P*S u v j*P
  rw [projection_P.isSelfAdjoint.star_eq]

theorem blockCorner_off (u v : ℝ) (i j : ι) :
    (blockCorner u v i j false true : Operator ι)=CornerRerouting.offDiagonal P (edgePolar u v i) (S u v j) := by
  change P*S u v j*star (edgePolar u v i)=P*S u v j*(1-P)*star (edgePolar u v i)
  have hh : (1-P)*star (edgePolar u v i)=star (edgePolar u v i) := by
    simpa only [star_mul,star_sub (R := Operator ι),star_one,projection_P.isSelfAdjoint.star_eq]
      using congrArg star (edgePolar_right u v i)
  rw [mul_assoc _ (1-P),hh]

theorem blockCorner_remaining (u v : ℝ) (i j : ι) :
    (blockCorner u v i j true true : Operator ι)=CornerRerouting.remaining P (edgePolar u v i) (S u v j) := by
  change edgePolar u v i*S u v j*star (edgePolar u v i)=
    edgePolar u v i*(1-P)*S u v j*(1-P)*star (edgePolar u v i)
  have hh : (1-P)*star (edgePolar u v i)=star (edgePolar u v i) := by
    simpa only [star_mul,star_sub (R := Operator ι),star_one,projection_P.isSelfAdjoint.star_eq]
      using congrArg star (edgePolar_right u v i)
  rw [edgePolar_right,mul_assoc _ (1-P),hh]

variable (u v : ℝ) (hv : 0<v) (hvu : v<u)

theorem pAmbient_recovered (M : StarSubalgebra ℂ (PCorner ℕ))
    (hbase : ∀ a : Base u v,(a:PCorner ℕ)∈M)
    (hout : ∀ i n,(cornerAbsorption u v hv hvu).output i n+
      star ((cornerAbsorption u v hv hvu).output (CircularRotation.flip i) n)∈M) :
    pAmbient u v ≤ StarSubalgebra.centralizer ℂ
      (StarSubalgebra.centralizer ℂ (M : Set (PCorner ℕ)) : Set (PCorner ℕ)) := by
  intro X hX
  have htest (T : PCorner ℕ) (hT : T∈StarSubalgebra.centralizer ℂ (M : Set (PCorner ℕ))) : T*X=X*T := by
    have hc (a : PCorner ℕ) (ha : a∈M) : Commute (T:Operator ℕ) (a:Operator ℕ) :=
      (congrArg (fun b : PCorner ℕ => (b:Operator ℕ))
        (((StarSubalgebra.mem_centralizer_iff ℂ).mp hT a ha).1)).symm
    have hblocks (j : ℕ) (r s : Bool) := hc (blockCorner u v 0 j r s)
      (absorbed_block_recovery u v hv hvu M hbase hout j r s)
    apply Subtype.ext
    apply full_corner_commutant u v hv hvu (0:ℕ) (X:Operator ℕ) (T:Operator ℕ) hX X.property T.property
    · exact hc (pSupport u v 0 1 true) (hbase (pSupport u v 0 1 true))
    · intro j;rw [← blockCorner_diagonal u v 0 j];exact hblocks j false false
    · intro j;rw [← blockCorner_off u v 0 j];exact hblocks j false true
    · intro j
      rw [← blockCorner_off u v 0 j]
      exact hc (star (blockCorner u v 0 j false true))
        (star_mem (absorbed_block_recovery u v hv hvu M hbase hout j false true))
    · intro j;rw [← blockCorner_remaining u v 0 j];exact hblocks j true true
  rw [StarSubalgebra.mem_centralizer_iff]
  intro T hT
  exact ⟨htest T hT,htest (star T) (star_mem hT)⟩
end FreeGroupFactorMain.WeightedFock

end

end OAI