| import OAI.Analysis.InterpolatedFactors.Diagonal |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| universe u_1 u_2 u_3 |
|
|
| namespace FreeGroupFactorMain.GaussianSplit |
| variable {E : Type u_1} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] |
| variable (B : StarSubalgebra ℂ (E →L[ℂ] E)) (C : E →L[ℂ] E) (Ω : E) |
| variable (hC : ∀ a : B,star C*(a : E →L[ℂ] E)*C=(inner ℂ Ω ((a : E →L[ℂ] E) Ω)) • 1) |
| variable (hΩ : ∀ a : B,star C ((a : E →L[ℂ] E) Ω)=0) |
| variable (d : B) (hd : IsStarProjection d) (hcentral : ∀ a : B,Commute d a) |
|
|
| def cut (r : Bool) : B := if r then d else 1-d |
|
|
| include hd in |
| theorem cut_star (r : Bool) : star (cut B d r)=cut B d r := by |
| cases r <;> simp only [cut,Bool.false_eq_true,ite_false,ite_true,star_sub (R := B),star_one,hd.isSelfAdjoint.star_eq] |
|
|
| include hd in |
| theorem cut_d (r : Bool) : cut B d r*d=if r then d else 0 := by |
| cases r <;> simp only [cut,Bool.false_eq_true,ite_false,ite_true,sub_mul,one_mul,hd.isIdempotentElem.eq,sub_self] |
|
|
| include hd hcentral in |
| theorem cut_false_a_d (a : B) : cut B d false*a*d=0 := by |
| rw [mul_assoc,← (hcentral a).eq,← mul_assoc,cut_d B d hd] |
| simp only [Bool.false_eq_true,ite_false,zero_mul] |
|
|
| def block (r s : Bool) : E →L[ℂ] E := (cut B d r : E →L[ℂ] E)*C*(cut B d s : E →L[ℂ] E) |
|
|
| def D : E →L[ℂ] E := (d : E →L[ℂ] E)*C*(d : E →L[ℂ] E) |
|
|
| def covariance (a : B) : B := (inner ℂ Ω (((d*a*d : B) : E →L[ℂ] E) Ω)) • d |
|
|
| include hC hd in |
| theorem D_contraction (a : B) : star (D B C d)*(a : E →L[ℂ] E)*D B C d= |
| (covariance B Ω d a : E →L[ℂ] E) := by |
| have he := hC (d*a*d) |
| have hs : star (d : E →L[ℂ] E)=(d : E →L[ℂ] E) := congrArg Subtype.val hd.isSelfAdjoint.star_eq |
| have hid : (d : E →L[ℂ] E)*(d : E →L[ℂ] E)=(d : E →L[ℂ] E) := congrArg Subtype.val hd.isIdempotentElem.eq |
| change star C*((d : E →L[ℂ] E)*(a : E →L[ℂ] E)*(d : E →L[ℂ] E))*C=_ at he |
| calc |
| _ = (d : E →L[ℂ] E)*(star C*((d : E →L[ℂ] E)*(a : E →L[ℂ] E)*(d : E →L[ℂ] E))*C)*(d : E →L[ℂ] E) := by |
| simp only [D,star_mul,hs,mul_assoc] |
| _ = _ := by rw [he,mul_smul_comm,smul_mul_assoc,mul_one,hid];rfl |
|
|
| include hΩ hd in |
| theorem D_annihilation (a : B) : star (D B C d) ((a : E →L[ℂ] E) Ω)=0 := by |
| have he := hΩ (d*a) |
| have hs : star (d : E →L[ℂ] E)=(d : E →L[ℂ] E) := congrArg Subtype.val hd.isSelfAdjoint.star_eq |
| simp only [D,star_mul,hs,mul_apply_eq_comp] |
| change star C ((d : E →L[ℂ] E) ((a : E →L[ℂ] E) Ω))=0 at he |
| rw [he,map_zero] |
|
|
| include hC hd in |
| theorem block_contraction (r s r' s' : Bool) (a : B) : |
| star (block B C d r s)*(a : E →L[ℂ] E)*block B C d r' s'= |
| (inner ℂ ((cut B d r : E →L[ℂ] E) Ω) |
| ((a : E →L[ℂ] E) ((cut B d r' : E →L[ℂ] E) Ω))) • |
| ((cut B d s : E →L[ℂ] E)*(cut B d s' : E →L[ℂ] E)) := by |
| have hs (r) : star (cut B d r : E →L[ℂ] E)=(cut B d r : E →L[ℂ] E) := |
| congrArg Subtype.val (cut_star B d hd r) |
| have he := hC (cut B d r*a*cut B d r') |
| change star C*((cut B d r : E →L[ℂ] E)*(a : E →L[ℂ] E)*(cut B d r' : E →L[ℂ] E))*C=_ at he |
| calc |
| _ = (cut B d s : E →L[ℂ] E)* |
| (star C*((cut B d r : E →L[ℂ] E)*(a : E →L[ℂ] E)*(cut B d r' : E →L[ℂ] E))*C)* |
| (cut B d s' : E →L[ℂ] E) := by simp only [block,star_mul,hs,mul_assoc] |
| _ = _ := by |
| rw [he,mul_smul_comm,smul_mul_assoc,mul_one] |
| congr 1 |
| change inner ℂ Ω ((cut B d r : E →L[ℂ] E) ((a : E →L[ℂ] E) ((cut B d r' : E →L[ℂ] E) Ω)))=_ |
| rw [← ContinuousLinearMap.adjoint_inner_left] |
| change inner ℂ ((star (cut B d r : E →L[ℂ] E)) Ω) _=_ |
| rw [hs r] |
|
|
| include hΩ hd in |
| theorem block_annihilation (r s : Bool) (a : B) : star (block B C d r s) ((a : E →L[ℂ] E) Ω)=0 := by |
| have he := hΩ (cut B d r*a) |
| have hs (r) : star (cut B d r : E →L[ℂ] E)=(cut B d r : E →L[ℂ] E) := |
| congrArg Subtype.val (cut_star B d hd r) |
| simp only [block,star_mul,hs,mul_apply_eq_comp] |
| change star C ((cut B d r : E →L[ℂ] E) ((a : E →L[ℂ] E) Ω))=0 at he |
| rw [he,map_zero] |
|
|
| include hC hd hcentral in |
| theorem block_D (r s : Bool) (hrs : ¬(r=true ∧ s=true)) (a : B) : |
| star (block B C d r s)*(a : E →L[ℂ] E)*D B C d=0 := by |
| have he := block_contraction B C Ω hC d hd r s true true a |
| change star (block B C d r s)*(a : E →L[ℂ] E)*D B C d= |
| (inner ℂ ((cut B d r : E →L[ℂ] E) Ω) |
| ((a : E →L[ℂ] E) ((d : E →L[ℂ] E) Ω))) • |
| ((cut B d s : E →L[ℂ] E)*(d : E →L[ℂ] E)) at he |
| rw [he] |
| cases s with |
| | false => |
| have hz : (cut B d false : E →L[ℂ] E)*(d : E →L[ℂ] E)=0 := |
| congrArg Subtype.val (cut_d B d hd false) |
| rw [hz,smul_zero (M := ℂ) (A := E →L[ℂ] E)] |
| | true => |
| have hr : r=false := by cases r <;> simp_all |
| subst r |
| have hz := congrArg Subtype.val (cut_false_a_d B d hd hcentral a) |
| change (cut B d false : E →L[ℂ] E)*(a : E →L[ℂ] E)*(d : E →L[ℂ] E)=0 at hz |
| have hs : star (cut B d false : E →L[ℂ] E)=(cut B d false : E →L[ℂ] E) := |
| congrArg Subtype.val (cut_star B d hd false) |
| rw [← ContinuousLinearMap.adjoint_inner_right] |
| change inner ℂ Ω ((star (cut B d false : E →L[ℂ] E)*(a : E →L[ℂ] E)*(d : E →L[ℂ] E)) Ω) • _=0 |
| rw [hs,hz,zero_apply,inner_zero_right,zero_smul ℂ (A := E →L[ℂ] E)] |
|
|
| def filled : StarSubalgebra ℂ (E →L[ℂ] E) := |
| StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ |
| (insert (D B C d+star (D B C d)) (B : Set (E →L[ℂ] E))) : Set (E →L[ℂ] E)) |
|
|
| include hC hΩ hd hcentral in |
|
|
| theorem residual_covariance (r s r' s' : Bool) (hrs : ¬(r=true ∧ s=true)) |
| (hrs' : ¬(r'=true ∧ s'=true)) (T : filled B C d) : |
| star (block B C d r s)*(T : E →L[ℂ] E)*block B C d r' s'= |
| (inner ℂ ((cut B d r : E →L[ℂ] E) Ω) |
| ((T : E →L[ℂ] E) ((cut B d r' : E →L[ℂ] E) Ω))) • |
| ((cut B d s : E →L[ℂ] E)*(cut B d s' : E →L[ℂ] E)) := by |
| apply GaussianExtension.covariance_extension B (D B C d) (covariance B Ω d) |
| (D_contraction B C Ω hC d hd) (block B C d r s) (block B C d r' s') _ |
| ((cut B d r : E →L[ℂ] E) Ω) ((cut B d r' : E →L[ℂ] E) Ω) |
| (fun a => D_annihilation B C Ω hΩ d hd (a*cut B d r)) |
| (fun a => D_annihilation B C Ω hΩ d hd (a*cut B d r')) |
| (block_D B C Ω hC d hd hcentral r s hrs) _ |
| (block_contraction B C Ω hC d hd r s r' s') (T : E →L[ℂ] E) T.property |
| intro a |
| have he := congrArg star (block_D B C Ω hC d hd hcentral r' s' hrs' (star a)) |
| simpa only [star_mul,star_star,star_zero (E →L[ℂ] E),StarMemClass.coe_star,mul_assoc] using he |
|
|
| include hC hΩ hd hcentral in |
| theorem residual_annihilation (r s : Bool) (hrs : ¬(r=true ∧ s=true)) (T : filled B C d) : |
| star (block B C d r s) ((T : E →L[ℂ] E) Ω)=0 := |
| GaussianExtension.annihilation_extension B (D B C d) (covariance B Ω d) |
| (D_contraction B C Ω hC d hd) (block B C d r s) Ω |
| (D_annihilation B C Ω hΩ d hd) (block_annihilation B C Ω hΩ d hd r s) |
| (block_D B C Ω hC d hd hcentral r s hrs) T T.property |
| end FreeGroupFactorMain.GaussianSplit |
|
|
| namespace FreeGroupFactorMain.WeightedFock |
|
|
| section |
| open FreeFock |
| variable {ι : Type u_2} [DecidableEq ι] |
|
|
| theorem edgeDefect_commute (u v : ℝ) (i : ι) (T : edgeAlgebra u v i) : |
| Commute (edgeDefect u v i) (T : Operator ι) := by |
| have hl (a : edgeAlgebra u v i) : |
| edgeDefect u v i*(a : Operator ι)*edgeDefect u v i=(a : Operator ι)*edgeDefect u v i := by |
| obtain ⟨c,hc⟩ := edge_algebra_scalar_on_defect u v i a |
| rw [mul_assoc,hc,mul_smul_comm,(edgeDefect_projection u v i).isIdempotentElem.eq] |
| have hr := congrArg star (hl (star T)) |
| simp only [star_mul,StarMemClass.coe_star,star_star, |
| (edgeDefect_projection u v i).isSelfAdjoint.star_eq,← mul_assoc] at hr |
| exact hr.symm.trans (hl T) |
|
|
| def defectAsEdge (u v : ℝ) (i : ι) : edgeAlgebra u v i := |
| ⟨edgeDefect u v i,edgeDefect_mem_edge u v i⟩ |
|
|
| theorem defectAsEdge_projection (u v : ℝ) (i : ι) : IsStarProjection (defectAsEdge u v i) := by |
| constructor |
| · apply Subtype.ext |
| exact (edgeDefect_projection u v i).isIdempotentElem.eq |
| · apply Subtype.ext |
| exact (edgeDefect_projection u v i).isSelfAdjoint.star_eq |
|
|
| theorem defectAsEdge_central (u v : ℝ) (i : ι) (a : edgeAlgebra u v i) : |
| Commute (defectAsEdge u v i) a := Subtype.ext (edgeDefect_commute u v i a).eq |
|
|
| theorem fresh_C_edge_contraction (u v : ℝ) (i j : ι) (hji : j≠i) (a : edgeAlgebra u v i) : |
| star (C u v j)*(a : Operator ι)*C u v j= |
| (inner ℂ (vacuum u v) ((a : Operator ι) (vacuum u v))) • 1 := by |
| have hh := fresh_C_contraction u v {i} j j hji hji |
| ⟨a,edgeAlgebra_le_old u v {i} i (Set.mem_singleton i) a.property⟩ |
| simpa only [ite_true,vacuumTrace] using hh |
|
|
| theorem fresh_C_edge_annihilation (u v : ℝ) (i j : ι) (hji : j≠i) (a : edgeAlgebra u v i) : |
| star (C u v j) ((a : Operator ι) (vacuum u v))=0 := |
| fresh_C_annihilates_old_vacuum u v {i} j hji |
| ⟨a,edgeAlgebra_le_old u v {i} i (Set.mem_singleton i) a.property⟩ |
|
|
| def splitCut (u v : ℝ) (i : ι) (b : Bool) : Operator ι := |
| GaussianSplit.cut (edgeAlgebra u v i) (defectAsEdge u v i) b |
|
|
| def splitBlock (u v : ℝ) (i j : ι) (r s : Bool) : Operator ι := |
| GaussianSplit.block (edgeAlgebra u v i) (C u v j) (defectAsEdge u v i) r s |
|
|
| theorem splitBlock_filled_covariance (u v : ℝ) (i j : ι) (hji : j≠i) |
| (r s r' s' : Bool) (hrs : ¬(r=true ∧ s=true)) (hrs' : ¬(r'=true ∧ s'=true)) |
| (T : filledEdgeAlgebra u v i j) : |
| star (splitBlock u v i j r s)*(T : Operator ι)*splitBlock u v i j r' s'= |
| (inner ℂ (splitCut u v i r (vacuum u v)) |
| ((T : Operator ι) (splitCut u v i r' (vacuum u v)))) • |
| (splitCut u v i s*splitCut u v i s') := |
| GaussianSplit.residual_covariance (edgeAlgebra u v i) (C u v j) (vacuum u v) |
| (fresh_C_edge_contraction u v i j hji) (fresh_C_edge_annihilation u v i j hji) |
| (defectAsEdge u v i) (defectAsEdge_projection u v i) (defectAsEdge_central u v i) |
| r s r' s' hrs hrs' T |
|
|
| theorem splitBlock_filled_annihilation (u v : ℝ) (i j : ι) (hji : j≠i) |
| (r s : Bool) (hrs : ¬(r=true ∧ s=true)) (T : filledEdgeAlgebra u v i j) : |
| star (splitBlock u v i j r s) ((T : Operator ι) (vacuum u v))=0 := |
| GaussianSplit.residual_annihilation (edgeAlgebra u v i) (C u v j) (vacuum u v) |
| (fresh_C_edge_contraction u v i j hji) (fresh_C_edge_annihilation u v i j hji) |
| (defectAsEdge u v i) (defectAsEdge_projection u v i) (defectAsEdge_central u v i) |
| r s hrs T |
|
|
| theorem splitCut_mem_edge (u v : ℝ) (i : ι) (b : Bool) : splitCut u v i b∈edgeAlgebra u v i := |
| (GaussianSplit.cut (edgeAlgebra u v i) (defectAsEdge u v i) b).property |
|
|
| theorem splitCut_selfAdjoint (u v : ℝ) (i : ι) (b : Bool) : IsSelfAdjoint (splitCut u v i b) := |
| congrArg Subtype.val (GaussianSplit.cut_star (edgeAlgebra u v i) (defectAsEdge u v i) |
| (defectAsEdge_projection u v i) b) |
|
|
| def splitPair (u v : ℝ) (i j : ι) (r s : Bool) : Operator ι := |
| splitBlock u v i j r s+star (splitBlock u v i j s r) |
|
|
| theorem splitPair_eq (u v : ℝ) (i j : ι) (r s : Bool) : |
| splitPair u v i j r s=splitCut u v i r*S u v j*splitCut u v i s := by |
| change splitCut u v i r*C u v j*splitCut u v i s+ |
| star (splitCut u v i s*C u v j*splitCut u v i r)=_ |
| simp only [S_eq,star_mul,(splitCut_selfAdjoint u v i r).star_eq, |
| (splitCut_selfAdjoint u v i s).star_eq,mul_add,add_mul,mul_assoc] |
|
|
| theorem splitPair_mem_ambient (u v : ℝ) (i j : ι) (r s : Bool) : |
| splitPair u v i j r s∈ambientAlgebra u v := by |
| rw [splitPair_eq] |
| exact mul_mem (mul_mem (edgeAlgebra_le_ambient u v i (splitCut_mem_edge u v i r)) |
| (S_mem_ambient u v j)) (edgeAlgebra_le_ambient u v i (splitCut_mem_edge u v i s)) |
|
|
| theorem splitPair_reconstruct (u v : ℝ) (i j : ι) : |
| S u v j=splitPair u v i j false false+splitPair u v i j false true+ |
| splitPair u v i j true false+splitPair u v i j true true := by |
| simp only [splitPair_eq] |
| change S u v j=(1-edgeDefect u v i)*S u v j*(1-edgeDefect u v i)+ |
| (1-edgeDefect u v i)*S u v j*edgeDefect u v i+ |
| edgeDefect u v i*S u v j*(1-edgeDefect u v i)+ |
| edgeDefect u v i*S u v j*edgeDefect u v i |
| simp only [sub_mul, mul_sub, one_mul, mul_one] |
| abel |
|
|
| end |
|
|
| open FreeFock |
| variable {ι : Type u_3} [DecidableEq ι] |
|
|
| def residualLeg (u v : ℝ) (i : ι) : Option Bool → Operator ι |
| | none => edgeDefect u v i |
| | some false => edgeRange u v i |
| | some true => edgePolar u v i |
|
|
| def residualSupport (u v : ℝ) (i : ι) : Option Bool → Operator ι |
| | none => edgeDefect u v i |
| | some _ => edgeRange u v i |
|
|
| def residualCut : Option Bool → Bool |
| | none => true |
| | some _ => false |
|
|
| theorem residualLeg_mem_edge (u v : ℝ) (i : ι) (r : Option Bool) : |
| residualLeg u v i r∈edgeAlgebra u v i := by |
| cases r with |
| | none => exact edgeDefect_mem_edge u v i |
| | some r => cases r |
| · exact edgeRange_mem_edge u v i |
| · exact edgePolar_mem_edge u v i |
|
|
| theorem P_mul_residualLeg (u v : ℝ) (i : ι) (r : Option Bool) : |
| P*residualLeg u v i r=residualLeg u v i r := by |
| cases r with |
| | none => exact P_mul_edgeDefect u v i |
| | some r => cases r |
| · exact edgeRange_le_P u v i |
| · exact edgePolar_left u v i |
|
|
| theorem edgePolar_mul_defect (u v : ℝ) (i : ι) : edgePolar u v i*edgeDefect u v i=0 := by |
| rw [← P_mul_edgeDefect u v i,← mul_assoc,edgePolar_mul_P,zero_mul] |
|
|
| theorem edgePolar_mul_range (u v : ℝ) (i : ι) : edgePolar u v i*edgeRange u v i=0 := by |
| rw [← edgeRange_le_P u v i,← mul_assoc,edgePolar_mul_P,zero_mul] |
|
|
| theorem defect_mul_star_edgePolar (u v : ℝ) (i : ι) : |
| edgeDefect u v i*star (edgePolar u v i)=0 := by |
| simpa only [star_mul,(edgeDefect_projection u v i).isSelfAdjoint.star_eq,star_zero (Operator ι)] |
| using congrArg star (edgePolar_mul_defect u v i) |
|
|
| theorem range_mul_star_edgePolar (u v : ℝ) (i : ι) : |
| edgeRange u v i*star (edgePolar u v i)=0 := by |
| simpa only [star_mul,(edgeRange_projection u v i).isSelfAdjoint.star_eq,star_zero (Operator ι)] |
| using congrArg star (edgePolar_mul_range u v i) |
|
|
| theorem residualLeg_mul_star (u v : ℝ) (i : ι) (r s : Option Bool) : |
| residualLeg u v i r*star (residualLeg u v i s)= |
| if r=s then residualSupport u v i r else 0 := by |
| rcases r with _ | (_ | _) <;> rcases s with _ | (_ | _) |
| all_goals simp only [residualLeg,residualSupport,Option.some.injEq,Option.some_ne_none, |
| reduceCtorEq,Bool.false_eq_true,Bool.true_eq_false,ite_true,ite_false] |
| · rw [(edgeDefect_projection u v i).isSelfAdjoint.star_eq] |
| exact (edgeDefect_projection u v i).isIdempotentElem.eq |
| · rw [(edgeRange_projection u v i).isSelfAdjoint.star_eq,defect_mul_edgeRange] |
| · exact defect_mul_star_edgePolar u v i |
| · rw [(edgeDefect_projection u v i).isSelfAdjoint.star_eq,edgeRange_mul_defect] |
| · rw [(edgeRange_projection u v i).isSelfAdjoint.star_eq] |
| exact (edgeRange_projection u v i).isIdempotentElem.eq |
| · exact range_mul_star_edgePolar u v i |
| · rw [(edgeDefect_projection u v i).isSelfAdjoint.star_eq,edgePolar_mul_defect] |
| · rw [(edgeRange_projection u v i).isSelfAdjoint.star_eq,edgePolar_mul_range] |
| · rfl |
|
|
| theorem residualLeg_cut (u v : ℝ) (i : ι) (r : Option Bool) : |
| residualLeg u v i r*splitCut u v i (residualCut r)=residualLeg u v i r := by |
| rcases r with _ | (_ | _) |
| · exact (edgeDefect_projection u v i).isIdempotentElem.eq |
| · change edgeRange u v i*(1-edgeDefect u v i)=edgeRange u v i |
| rw [mul_sub,mul_one,edgeRange_mul_defect,sub_zero] |
| · change edgePolar u v i*(1-edgeDefect u v i)=edgePolar u v i |
| rw [mul_sub,mul_one,edgePolar_mul_defect,sub_zero] |
|
|
| theorem cut_star_residualLeg (u v : ℝ) (i : ι) (r : Option Bool) : |
| splitCut u v i (residualCut r)*star (residualLeg u v i r)=star (residualLeg u v i r) := by |
| simpa only [star_mul,(splitCut_selfAdjoint u v i (residualCut r)).star_eq] |
| using congrArg star (residualLeg_cut u v i r) |
|
|
| theorem residualLeg_trace_covariance (u v : ℝ) (hu : u≠0) (hv : v≠0) |
| (i : ι) (r s : Option Bool) (T : ambientAlgebra (ι := ι) u v) : |
| vacuumTrace u v (star (residualLeg u v i r)*(T : Operator ι)*residualLeg u v i s)= |
| if r=s then vacuumTrace u v ((T : Operator ι)*residualSupport u v i r) else 0 := by |
| have ht := ambient_trace_mul u v hu hv |
| ⟨star (residualLeg u v i r),star_mem (edgeAlgebra_le_ambient u v i (residualLeg_mem_edge u v i r))⟩ |
| (T*⟨residualLeg u v i s,edgeAlgebra_le_ambient u v i (residualLeg_mem_edge u v i s)⟩) |
| change vacuumTrace u v (star (residualLeg u v i r)*((T : Operator ι)*residualLeg u v i s))= |
| vacuumTrace u v (((T : Operator ι)*residualLeg u v i s)*star (residualLeg u v i r)) at ht |
| rw [mul_assoc,ht,mul_assoc,residualLeg_mul_star] |
| by_cases h : r=s |
| · subst s; simp only [ite_true] |
| · simp only [h,Ne.symm h,ite_false,mul_zero,vacuumTrace,zero_apply,inner_zero_right] |
|
|
| def residualCreation (u v : ℝ) (i j : ι) (r s : Option Bool) : Operator ι := |
| residualLeg u v i r*C u v j*star (residualLeg u v i s) |
|
|
| theorem residualCreation_split (u v : ℝ) (i j : ι) (r s : Option Bool) : |
| residualCreation u v i j r s= |
| residualLeg u v i r*splitBlock u v i j (residualCut r) (residualCut s)*star (residualLeg u v i s) := by |
| change _=residualLeg u v i r*(splitCut u v i (residualCut r)*C u v j* |
| splitCut u v i (residualCut s))*star (residualLeg u v i s) |
| simp only [mul_assoc] |
| rw [cut_star_residualLeg] |
| rw [← mul_assoc, residualLeg_cut] |
| rfl |
|
|
| theorem residual_allowed (r s : Option Bool) (h : ¬(r=none ∧ s=none)) : |
| ¬(residualCut r=true ∧ residualCut s=true) := by |
| rcases r with _ | (_ | _) <;> rcases s with _ | (_ | _) <;> simp_all [residualCut] |
|
|
| theorem residualCreation_filled_covariance (u v : ℝ) (hu : u≠0) (hv : v≠0) |
| (i j : ι) (hji : j≠i) (r s r' s' : Option Bool) |
| (hrs : ¬(r=none ∧ s=none)) (hrs' : ¬(r'=none ∧ s'=none)) |
| (T : filledEdgeAlgebra u v i j) : |
| star (residualCreation u v i j r s)*(T : Operator ι)*residualCreation u v i j r' s'= |
| if r=r' ∧ s=s' then |
| vacuumTrace u v ((T : Operator ι)*residualSupport u v i r) • residualSupport u v i s else 0 := by |
| let a (t : Option Bool) : filledEdgeAlgebra u v i j := |
| ⟨residualLeg u v i t,edgeAlgebra_le_filled u v i j (residualLeg_mem_edge u v i t)⟩ |
| have hc := splitBlock_filled_covariance u v i j hji (residualCut r) (residualCut s) |
| (residualCut r') (residualCut s') (residual_allowed r s hrs) (residual_allowed r' s' hrs') |
| (star (a r)*T*a r') |
| have hi : inner ℂ (splitCut u v i (residualCut r) (vacuum u v)) |
| (((star (a r)*T*a r' : filledEdgeAlgebra u v i j) : Operator ι) |
| (splitCut u v i (residualCut r') (vacuum u v)))= |
| vacuumTrace u v (star (residualLeg u v i r)*(T : Operator ι)*residualLeg u v i r') := by |
| rw [← ContinuousLinearMap.adjoint_inner_right] |
| change inner ℂ (vacuum u v) ((star (splitCut u v i (residualCut r))* |
| (star (residualLeg u v i r)*(T : Operator ι)*residualLeg u v i r')* |
| splitCut u v i (residualCut r')) (vacuum u v))=_ |
| rw [(splitCut_selfAdjoint u v i (residualCut r)).star_eq] |
| simp only [← mul_assoc,cut_star_residualLeg] |
| rw [mul_assoc _ _ (splitCut u v i (residualCut r')),residualLeg_cut] |
| rfl |
| rw [hi] at hc |
| calc |
| _ = residualLeg u v i s*(star (splitBlock u v i j (residualCut r) (residualCut s))* |
| (star (residualLeg u v i r)*(T : Operator ι)*residualLeg u v i r')* |
| splitBlock u v i j (residualCut r') (residualCut s'))*star (residualLeg u v i s') := by |
| rw [residualCreation_split,residualCreation_split] |
| simp only [star_mul,star_star,mul_assoc] |
| _ = _ := by |
| change (residualLeg u v i s*(star (splitBlock u v i j (residualCut r) (residualCut s))* |
| ((star (a r)*T*a r' : filledEdgeAlgebra u v i j) : Operator ι)* |
| splitBlock u v i j (residualCut r') (residualCut s'))*star (residualLeg u v i s'))=_ |
| rw [hc,mul_smul_comm,smul_mul_assoc] |
| rw [← mul_assoc,mul_assoc _ (splitCut u v i (residualCut s')), |
| cut_star_residualLeg,residualLeg_cut,residualLeg_mul_star] |
| rw [residualLeg_trace_covariance u v hu hv i r r' |
| ⟨T,filledEdgeAlgebra_le_ambient u v i j T.property⟩] |
| by_cases hr : r=r' <;> by_cases hs : s=s' <;> |
| simp only [hr,hs,ite_true,ite_false,zero_smul ℂ (A := Operator ι), |
| smul_zero (M := ℂ) (A := Operator ι),true_and,false_and,and_false] |
|
|
| end FreeGroupFactorMain.WeightedFock |
|
|
| end |
|
|
| end OAI |
|
|
