| import OAI.Analysis.InterpolatedFactors.Fresh |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| universe u_1 u_2 |
|
|
| namespace FreeGroupFactorMain.WeightedFock |
|
|
| section |
| open FreeFock |
| variable {ι : Type u_1} [DecidableEq ι] |
|
|
| theorem annihilation_commute_diagonalInsert (n j : ι) (hnj : n≠j) (r : Bool) (w : Path ι) : |
| Commute (star (creation n r)) (diagonalInsert j w) := by |
| have hA : Commute (star (creation n r)) (rightInsert j w) := by |
| have hh := annihilation_rightInsert n j r w |
| exact (show Commute _ _ from by |
| change _ * _ = _ * _ |
| simpa only [hnj,ite_false,add_zero] using hh) |
| have ht := (terminalVertex_commute_creation (start w) n r).star_star |
| simp only [terminalVertex_star] at ht |
| exact hA.mul_right ht.symm |
|
|
| theorem Cstar_commute_diagonalInsert (u v : ℝ) (n j : ι) (hnj : n≠j) (w : Path ι) : |
| Commute (star (C u v n)) (diagonalInsert j w) := by |
| have hh := ((annihilation_commute_diagonalInsert n j hnj true w).smul_left (u:ℂ)).add_left |
| ((annihilation_commute_diagonalInsert n j hnj false w).smul_left (v:ℂ)) |
| simpa only [C,star_add (R := Operator ι),star_smul,Complex.star_def,Complex.conj_ofReal] using hh |
|
|
| theorem fresh_C_edge_root (u v : ℝ) (i n : ι) (hni : n≠i) (T : edgeAlgebra u v i) (s : Bool) : |
| star (C u v n) ((T : Operator ι) (lp.single 2 ([],s) 1))=0 := by |
| let a : oldAlgebra u v {i} := ⟨T,edgeAlgebra_le_old u v {i} i (Set.mem_singleton i) T.property⟩ |
| have hh (r) : star (creation n r) ((T : Operator ι) (lp.single 2 ([],s) 1))=0 := |
| annihilation_old_root u v {i} n hni a r s |
| simp only [C,star_add (R := Operator ι),star_smul,Complex.star_def,Complex.conj_ofReal,add_apply,_root_.smul_apply, |
| hh,smul_zero,add_zero] |
|
|
| theorem fresh_C_diagonal_edge (u v : ℝ) (i n j : ι) (hni : n≠i) (hnj : n≠j) |
| (T : edgeAlgebra u v i) (r : Bool) : |
| star (C u v n)*(T : Operator ι)*edgeCreation j r r=0 := by |
| apply operator_basis_ext |
| intro w |
| by_cases hs : start w=r |
| · have hc := ((StarSubalgebra.mem_centralizer_iff ℂ).mp T.property _ |
| (diagonalInsert_mem_edgeCommutant u v i j w)).1 |
| have ht := DFunLike.congr_fun hc (lp.single 2 ([],r) 1) |
| simp only [mul_apply_eq_comp,diagonalInsert_nil,hs,ite_true] at ht |
| have ha := DFunLike.congr_fun (Cstar_commute_diagonalInsert u v n j hnj w).eq |
| ((T : Operator ι) (lp.single 2 ([],r) 1)) |
| simp only [mul_apply_eq_comp,fresh_C_edge_root u v i n hni T,map_zero] at ha |
| simpa only [mul_apply_eq_comp,edgeCreation_single,hs,ite_true,ht,zero_apply] using ha |
| · simp only [mul_apply_eq_comp,edgeCreation_single,hs,ite_false,map_zero,zero_apply] |
|
|
| theorem diagonal_weightedDefect (u v : ℝ) (i j k : ι) (hji : j≠i) (hjk : j≠k) |
| (T : edgeAlgebra u v i) (r : Bool) : |
| star (edgeCreation k r r)*(T : Operator ι)*weightedDefectCreation u v i j=0 := by |
| let a : edgeAlgebra u v i := T*⟨edgeDefect u v i,edgeDefect_mem_edge u v i⟩ |
| have hh := congrArg star (fresh_C_diagonal_edge u v i j k hji hjk (star a) r) |
| simp only [star_mul,star_star,star_zero (Operator ι),StarMemClass.coe_star] at hh |
| change star (edgeCreation k r r)*((T : Operator ι)*edgeDefect u v i)*C u v j=0 at hh |
| calc |
| _ = (star (edgeCreation k r r)*((T : Operator ι)*edgeDefect u v i)*C u v j)*edgeDefect u v i := by |
| simp only [weightedDefectCreation,mul_assoc] |
| _ = 0 := by rw [hh,zero_mul] |
|
|
| theorem weightedDefect_edge_root (u v : ℝ) (i j : ι) (hji : j≠i) |
| (T : edgeAlgebra u v i) (r : Bool) : |
| star (weightedDefectCreation u v i j) ((T : Operator ι) (lp.single 2 ([],r) 1))=0 := by |
| let a : edgeAlgebra u v i := ⟨edgeDefect u v i,edgeDefect_mem_edge u v i⟩*T |
| have hh := fresh_C_edge_root u v i j hji a r |
| simp only [weightedDefectCreation,star_mul,(edgeDefect_projection u v i).isSelfAdjoint.star_eq, |
| mul_apply_eq_comp] |
| change star (C u v j) (edgeDefect u v i ((T : Operator ι) (lp.single 2 ([],r) 1)))=0 at hh |
| rw [hh,map_zero] |
|
|
| theorem diagonal_filled_contraction (u v : ℝ) (i j k l : ι) (hji : j≠i) (hjk : j≠k) (hjl : j≠l) |
| (r s : Bool) (T : filledEdgeAlgebra u v i j) : |
| star (edgeCreation k r r)*(T : Operator ι)*edgeCreation l s s= |
| (inner ℂ (lp.single 2 ([],r) 1) ((T : Operator ι) (lp.single 2 ([],s) 1))) • |
| (if k=l ∧ r=s then vertex s else 0) := by |
| apply GaussianExtension.covariance_extension (edgeAlgebra u v i) (weightedDefectCreation u v i j) |
| (defectCovariance u v i) (weightedDefect_contraction u v i j hji) |
| (edgeCreation k r r) (edgeCreation l s s) _ (lp.single 2 ([],r) 1) (lp.single 2 ([],s) 1) |
| (fun a => weightedDefect_edge_root u v i j hji a r) |
| (fun a => weightedDefect_edge_root u v i j hji a s) |
| (fun a => diagonal_weightedDefect u v i j k hji hjk a r) _ _ (T : Operator ι) T.property |
| · intro a |
| have hh := congrArg star (diagonal_weightedDefect u v i j l hji hjl (star a) s) |
| simpa only [star_mul,star_star,star_zero (Operator ι),StarMemClass.coe_star,mul_assoc] using hh |
| · intro a |
| have hh := diagonal_edge_contraction u v i k l a r s |
| split_ifs with h |
| · simpa [h,lp.inner_single_left] using hh |
| · simpa only [h,ite_false,smul_zero] using hh |
|
|
| theorem diagonal_filled_annihilation (u v : ℝ) (i j k : ι) (hji : j≠i) (hjk : j≠k) |
| (r : Bool) (T : filledEdgeAlgebra u v i j) : |
| star (edgeCreation k r r) ((T : Operator ι) (vacuum u v))=0 := by |
| apply GaussianExtension.annihilation_extension (edgeAlgebra u v i) (weightedDefectCreation u v i j) |
| (defectCovariance u v i) (weightedDefect_contraction u v i j hji) |
| (edgeCreation k r r) (vacuum u v) (weightedDefect_annihilates_edge u v i j hji) _ |
| (fun a => diagonal_weightedDefect u v i j k hji hjk a r) T T.property |
| intro a |
| simp only [vacuum,map_add,map_smul,diagonal_annihilation_edge_root u v i k a, |
| smul_zero,add_zero] |
| end |
|
|
| open FreeFock |
| variable {ι : Type u_2} [DecidableEq ι] |
|
|
| theorem vertex_trace_inner (u v : ℝ) (r : Bool) (T : Operator ι) : |
| vacuumTrace u v (vertex r*T*vertex r)= |
| (weight u v r : ℂ)^2*inner ℂ (lp.single 2 ([],r) 1) (T (lp.single 2 ([],r) 1)) := by |
| unfold vacuumTrace |
| simp only [mul_apply_eq_comp] |
| rw [← ContinuousLinearMap.adjoint_inner_left] |
| change inner ℂ (star (vertex r) (vacuum u v)) (T (vertex r (vacuum u v)))=_ |
| rw [vertex_star,vertex_vacuum] |
| simp only [map_smul,inner_smul_left,inner_smul_right,Complex.conj_ofReal,pow_two,mul_assoc] |
|
|
| theorem supportedLeg_vertex (u v : ℝ) (i : ι) (r : Bool) : |
| supportedLeg u v i r*vertex (!r)=supportedLeg u v i r := by |
| cases r |
| · exact projection_P.isIdempotentElem.eq |
| · exact edgePolar_right u v i |
|
|
| theorem vertex_star_supportedLeg (u v : ℝ) (i : ι) (r : Bool) : |
| vertex (!r)*star (supportedLeg u v i r)=star (supportedLeg u v i r) := by |
| simpa only [star_mul,vertex_star] using congrArg star (supportedLeg_vertex u v i r) |
|
|
| theorem supportedLeg_root_trace (u v : ℝ) (hu : u≠0) (hv : v≠0) |
| (i : ι) (r : Bool) (T : ambientAlgebra (ι := ι) u v) : |
| (weight u v (!r) : ℂ)^2*inner ℂ (lp.single 2 ([],!r) 1) |
| ((star (supportedLeg u v i r)*(T : Operator ι)*supportedLeg u v i r) (lp.single 2 ([],!r) 1))= |
| vacuumTrace u v ((T : Operator ι)*legSupport u v i r) := by |
| rw [← vertex_trace_inner] |
| rw [← mul_assoc,← mul_assoc,vertex_star_supportedLeg,mul_assoc _ _ (vertex (!r)),supportedLeg_vertex] |
| simpa only [ite_true] using supportedLeg_trace_covariance u v hu hv i r r T |
|
|
| def transportedDiagonal (u v : ℝ) (i k : ι) (r : Bool) : Operator ι := |
| supportedLeg u v i r*edgeCreation k (!r) (!r)*star (supportedLeg u v i r) |
|
|
| def normalizedDiagonal (u v : ℝ) (i k : ι) (r : Bool) : Operator ι := |
| ((weight u v (!r) : ℂ)/(u:ℂ)) • transportedDiagonal u v i k r |
|
|
| theorem transportedDiagonal_filled_contraction (u v : ℝ) (i j k l : ι) |
| (hji : j≠i) (hjk : j≠k) (hjl : j≠l) (r s : Bool) (T : filledEdgeAlgebra u v i j) : |
| star (transportedDiagonal u v i k r)*(T : Operator ι)*transportedDiagonal u v i l s= |
| if k=l ∧ r=s then (inner ℂ (lp.single 2 ([],!r) 1) |
| ((star (supportedLeg u v i r)*(T : Operator ι)*supportedLeg u v i r) (lp.single 2 ([],!r) 1))) • |
| legSupport u v i r else 0 := by |
| let a (b : Bool) : filledEdgeAlgebra u v i j := |
| ⟨supportedLeg u v i b,edgeAlgebra_le_filled u v i j (supportedLeg_mem_edge u v i b)⟩ |
| have h := diagonal_filled_contraction u v i j k l hji hjk hjl (!r) (!s) (star (a r)*T*a s) |
| calc |
| _ = supportedLeg u v i r*(star (edgeCreation k (!r) (!r))* |
| ((star (a r)*T*a s : filledEdgeAlgebra u v i j) : Operator ι)*edgeCreation l (!s) (!s))* |
| star (supportedLeg u v i s) := by |
| simp only [transportedDiagonal,StarMemClass.coe_star,MulMemClass.coe_mul,star_mul,star_star,mul_assoc] |
| rfl |
| _ = _ := by |
| rw [h] |
| by_cases hr : r=s |
| · subst s |
| by_cases hk : k=l |
| · simp only [hk,ite_true,true_and,mul_smul_comm,smul_mul_assoc,supportedLeg_vertex, |
| supportedLeg_mul_star] |
| rfl |
| · simp only [hk,false_and,ite_false,smul_zero (M := ℂ) (A := Operator ι),mul_zero,zero_mul] |
| · have hr' : (!r)≠(!s) := by cases r <;> cases s <;> simp_all |
| simp only [hr,hr',and_false,ite_false,smul_zero (M := ℂ) (A := Operator ι),mul_zero,zero_mul] |
|
|
| theorem normalizedDiagonal_filled_covariance (u v : ℝ) (hu : u≠0) (hv : v≠0) |
| (i j k l : ι) (hji : j≠i) (hjk : j≠k) (hjl : j≠l) |
| (r s : Bool) (T : filledEdgeAlgebra u v i j) : |
| star (normalizedDiagonal u v i k r)*(T : Operator ι)*normalizedDiagonal u v i l s= |
| if k=l ∧ r=s then pVacuumTrace u v ((T : Operator ι)*legSupport u v i r) • legSupport u v i r else 0 := by |
| simp only [normalizedDiagonal,star_smul,Complex.star_def,map_div₀,Complex.conj_ofReal, |
| smul_mul_assoc,mul_smul_comm] |
| rw [transportedDiagonal_filled_contraction u v i j k l hji hjk hjl] |
| by_cases h : k=l ∧ r=s |
| · obtain ⟨hk,hrs⟩ := h |
| subst l;subst s |
| simp only [and_self,ite_true,smul_smul] |
| congr 1 |
| unfold pVacuumTrace |
| rw [← supportedLeg_root_trace u v hu hv i r ⟨T,filledEdgeAlgebra_le_ambient u v i j T.property⟩] |
| ring |
| · simp only [h,ite_false,smul_zero (M := ℂ) (A := Operator ι)] |
| end FreeGroupFactorMain.WeightedFock |
|
|
| end |
|
|
| end OAI |
|
|
