DibyashanuPati/PhysLean
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into Docs

Browse source
This commit is contained in:
jstoobysmith 2025-01-23 14:22:25 +00:00
commit fca75098f1
18 changed files with 163 additions and 314 deletions
Download patch file Download diff file Expand all files Collapse all files

63
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/Basic.lean
View file

@ -61,12 +61,10 @@ lemma ofCrAnList_cons (φ : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates) :
lemma ofCrAnList_append (φs φs' : List 𝓕.CrAnStates) :
ofCrAnList (φs ++ φs') = ofCrAnList φs * ofCrAnList φs' := by
dsimp only [ofCrAnList]
rw [List.map_append, List.prod_append]
simp [ofCrAnList, List.map_append]
lemma ofCrAnList_singleton (φ : 𝓕.CrAnStates) :
ofCrAnList [φ] = ofCrAnState φ := by
simp [ofCrAnList]
ofCrAnList [φ] = ofCrAnState φ := by simp [ofCrAnList]
/-- Maps a state to the sum of creation and annihilation operators in
creation and annihilation free-algebra. -/
@ -94,8 +92,7 @@ lemma ofStateList_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
ofStateList (φ :: φs) = ofState φ * ofStateList φs := rfl
lemma ofStateList_singleton (φ : 𝓕.States) :
ofStateList [φ] = ofState φ := by
simp [ofStateList]
ofStateList [φ] = ofState φ := by simp [ofStateList]
lemma ofStateList_append (φs φs' : List 𝓕.States) :
ofStateList (φs ++ φs') = ofStateList φs * ofStateList φs' := by
@ -104,13 +101,11 @@ lemma ofStateList_append (φs φs' : List 𝓕.States) :
lemma ofStateAlgebra_ofList_eq_ofStateList : (φs : List 𝓕.States) →
ofStateAlgebra (ofList φs) = ofStateList φs
| [] => by
simp [ofStateList]
| [] => by simp [ofStateList]
| φ :: φs => by
rw [ofStateList_cons, StateAlgebra.ofList_cons]
rw [map_mul]
simp only [ofStateAlgebra_ofState, mul_eq_mul_left_iff]
apply Or.inl (ofStateAlgebra_ofList_eq_ofStateList φs)
rw [ofStateList_cons, StateAlgebra.ofList_cons, map_mul, ofStateAlgebra_ofState,
mul_eq_mul_left_iff]
exact .inl (ofStateAlgebra_ofList_eq_ofStateList φs)
lemma ofStateList_sum (φs : List 𝓕.States) :
ofStateList φs = ∑ (s : CrAnSection φs), ofCrAnList s.1 := by
@ -144,21 +139,18 @@ def crPart : 𝓕.StateAlgebra →ₐ[ℂ] 𝓕.CrAnAlgebra :=
@[simp]
lemma crPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPart (StateAlgebra.ofState (States.inAsymp φ)) = ofCrAnState ⟨States.inAsymp φ, ()⟩ := by
dsimp only [crPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [crPart, StateAlgebra.ofState]
@[simp]
lemma crPart_position (φ : 𝓕.PositionStates) :
crPart (StateAlgebra.ofState (States.position φ)) =
ofCrAnState ⟨States.position φ, CreateAnnihilate.create⟩ := by
dsimp only [crPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [crPart, StateAlgebra.ofState]
@[simp]
lemma crPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPart (StateAlgebra.ofState (States.outAsymp φ)) = 0 := by
dsimp only [crPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [crPart, StateAlgebra.ofState]
/-- The algebra map taking an element of the free-state algbra to
the part of it in the creation and annihilation free algebra
@ -173,36 +165,26 @@ def anPart : 𝓕.StateAlgebra →ₐ[ℂ] 𝓕.CrAnAlgebra :=
@[simp]
lemma anPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPart (StateAlgebra.ofState (States.inAsymp φ)) = 0 := by
dsimp only [anPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [anPart, StateAlgebra.ofState]
@[simp]
lemma anPart_position (φ : 𝓕.PositionStates) :
anPart (StateAlgebra.ofState (States.position φ)) =
ofCrAnState ⟨States.position φ, CreateAnnihilate.annihilate⟩ := by
dsimp only [anPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [anPart, StateAlgebra.ofState]
@[simp]
lemma anPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPart (StateAlgebra.ofState (States.outAsymp φ)) = ofCrAnState ⟨States.outAsymp φ, ()⟩ := by
dsimp only [anPart, StateAlgebra.ofState]
rw [FreeAlgebra.lift_ι_apply]
simp [anPart, StateAlgebra.ofState]
lemma ofState_eq_crPart_add_anPart (φ : 𝓕.States) :
ofState φ = crPart (StateAlgebra.ofState φ) + anPart (StateAlgebra.ofState φ) := by
rw [ofState]
cases φ with
| inAsymp φ =>
dsimp only [statesToCrAnType]
simp
| position φ =>
dsimp only [statesToCrAnType]
rw [CreateAnnihilate.sum_eq]
simp
| outAsymp φ =>
dsimp only [statesToCrAnType]
simp
| inAsymp φ => simp [statesToCrAnType]
| position φ => simp [statesToCrAnType, CreateAnnihilate.sum_eq]
| outAsymp φ => simp [statesToCrAnType]
/-!
@ -223,11 +205,9 @@ lemma ofListBasis_eq_ofList (φs : List 𝓕.CrAnStates) :
erw [MonoidAlgebra.lift_apply]
simp only [zero_smul, Finsupp.sum_single_index, one_smul]
rw [@FreeMonoid.lift_apply]
simp only [List.prod]
match φs with
| [] => rfl
| φ :: φs =>
erw [List.map_cons]
| φ :: φs => erw [List.map_cons]
/-!
@ -239,8 +219,7 @@ lemma ofListBasis_eq_ofList (φs : List 𝓕.CrAnStates) :
noncomputable def mulLinearMap : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 where
toFun a := {
toFun := fun b => a * b,
map_add' := fun c d => by
simp [mul_add]
map_add' := fun c d => by simp [mul_add]
map_smul' := by simp}
map_add' := fun a b => by
ext c
@ -251,15 +230,13 @@ noncomputable def mulLinearMap : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕
simp [smul_mul']
lemma mulLinearMap_apply (a b : CrAnAlgebra 𝓕) :
mulLinearMap a b = a * b := by rfl
mulLinearMap a b = a * b := rfl
/-- The linear map associated with scalar-multiplication in `CrAnAlgebra`. -/
noncomputable def smulLinearMap (c : ℂ) : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 where
toFun a := c • a
map_add' := by simp
map_smul' m x := by
simp only [smul_smul, RingHom.id_apply]
rw [NonUnitalNormedCommRing.mul_comm]
map_smul' m x := by simp [smul_smul, RingHom.id_apply, NonUnitalNormedCommRing.mul_comm]
end CrAnAlgebra

237
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/NormalOrder.lean
View file

@ -38,20 +38,16 @@ def normalOrder : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 :=
lemma normalOrder_ofCrAnList (φs : List 𝓕.CrAnStates) :
normalOrder (ofCrAnList φs) = normalOrderSign φs • ofCrAnList (normalOrderList φs) := by
rw [← ofListBasis_eq_ofList]
simp only [normalOrder, Basis.constr_basis]
rw [← ofListBasis_eq_ofList, normalOrder, Basis.constr_basis]
lemma ofCrAnList_eq_normalOrder (φs : List 𝓕.CrAnStates) :
ofCrAnList (normalOrderList φs) = normalOrderSign φs • normalOrder (ofCrAnList φs) := by
rw [normalOrder_ofCrAnList, normalOrderList]
rw [smul_smul]
simp only [normalOrderSign]
rw [Wick.koszulSign_mul_self]
simp
rw [normalOrder_ofCrAnList, normalOrderList, smul_smul, normalOrderSign, Wick.koszulSign_mul_self,
one_smul]
lemma normalOrder_one : normalOrder (𝓕 := 𝓕) 1 = 1 := by
rw [← ofCrAnList_nil, normalOrder_ofCrAnList]
simp
rw [← ofCrAnList_nil, normalOrder_ofCrAnList, normalOrderSign_nil, normalOrderList_nil,
ofCrAnList_nil, one_smul]
/-!
@ -63,8 +59,7 @@ lemma normalOrder_ofCrAnList_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
normalOrder (ofCrAnList (φ :: φs)) =
ofCrAnState φ * normalOrder (ofCrAnList φs) := by
rw [normalOrder_ofCrAnList]
rw [normalOrderSign_cons_create φ hφ, normalOrderList_cons_create φ hφ φs]
rw [normalOrder_ofCrAnList, normalOrderSign_cons_create φ hφ, normalOrderList_cons_create φ hφ φs]
rw [ofCrAnList_cons, normalOrder_ofCrAnList, mul_smul_comm]
lemma normalOrder_create_mul (φ : 𝓕.CrAnStates)
@ -73,21 +68,18 @@ lemma normalOrder_create_mul (φ : 𝓕.CrAnStates)
normalOrder (ofCrAnState φ * a) = ofCrAnState φ * normalOrder a := by
change (normalOrder ∘ₗ mulLinearMap (ofCrAnState φ)) a =
(mulLinearMap (ofCrAnState φ) ∘ₗ normalOrder) a
refine LinearMap.congr_fun ?h a
apply ofCrAnListBasis.ext
intro l
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply]
rw [← ofCrAnList_cons]
rw [normalOrder_ofCrAnList_cons_create φ hφ]
rw [← ofCrAnList_cons, normalOrder_ofCrAnList_cons_create φ hφ]
lemma normalOrder_ofCrAnList_append_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
normalOrder (ofCrAnList (φs ++ [φ])) =
normalOrder (ofCrAnList φs) * ofCrAnState φ := by
rw [normalOrder_ofCrAnList]
rw [normalOrderSign_append_annihlate φ hφ φs, normalOrderList_append_annihilate φ hφ φs]
rw [ofCrAnList_append, ofCrAnList_singleton, normalOrder_ofCrAnList, smul_mul_assoc]
rw [normalOrder_ofCrAnList, normalOrderSign_append_annihlate φ hφ φs,
normalOrderList_append_annihilate φ hφ φs, ofCrAnList_append, ofCrAnList_singleton,
normalOrder_ofCrAnList, smul_mul_assoc]
lemma normalOrder_mul_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate)
@ -95,46 +87,35 @@ lemma normalOrder_mul_annihilate (φ : 𝓕.CrAnStates)
normalOrder (a * ofCrAnState φ) = normalOrder a * ofCrAnState φ := by
change (normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φ)) a =
(mulLinearMap.flip (ofCrAnState φ) ∘ₗ normalOrder) a
refine LinearMap.congr_fun ?h a
apply ofCrAnListBasis.ext
intro l
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk]
rw [← ofCrAnList_singleton, ← ofCrAnList_append, ofCrAnList_singleton]
rw [normalOrder_ofCrAnList_append_annihilate φ hφ]
rw [← ofCrAnList_singleton, ← ofCrAnList_append, ofCrAnList_singleton,
normalOrder_ofCrAnList_append_annihilate φ hφ]
lemma normalOrder_crPart_mul (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
normalOrder (crPart (StateAlgebra.ofState φ) * a) =
crPart (StateAlgebra.ofState φ) * normalOrder a := by
match φ with
| .inAsymp φ =>
dsimp only [crPart, StateAlgebra.ofState]
simp only [FreeAlgebra.lift_ι_apply]
rw [crPart, StateAlgebra.ofState, FreeAlgebra.lift_ι_apply]
exact normalOrder_create_mul ⟨States.inAsymp φ, ()⟩ rfl a
| .position φ =>
dsimp only [crPart, StateAlgebra.ofState]
simp only [FreeAlgebra.lift_ι_apply]
refine normalOrder_create_mul _ ?_ _
simp [crAnStatesToCreateAnnihilate]
| .outAsymp φ =>
simp
rw [crPart, StateAlgebra.ofState, FreeAlgebra.lift_ι_apply]
exact normalOrder_create_mul _ rfl _
| .outAsymp φ => simp
lemma normalOrder_mul_anPart (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
normalOrder (a * anPart (StateAlgebra.ofState φ)) =
normalOrder a * anPart (StateAlgebra.ofState φ) := by
match φ with
| .inAsymp φ =>
simp
| .inAsymp φ => simp
| .position φ =>
dsimp only [anPart, StateAlgebra.ofState]
simp only [FreeAlgebra.lift_ι_apply]
refine normalOrder_mul_annihilate _ ?_ _
simp [crAnStatesToCreateAnnihilate]
rw [anPart, StateAlgebra.ofState, FreeAlgebra.lift_ι_apply]
exact normalOrder_mul_annihilate _ rfl _
| .outAsymp φ =>
dsimp only [anPart, StateAlgebra.ofState]
simp only [FreeAlgebra.lift_ι_apply]
refine normalOrder_mul_annihilate _ ?_ _
simp [crAnStatesToCreateAnnihilate]
rw [anPart, StateAlgebra.ofState, FreeAlgebra.lift_ι_apply]
refine normalOrder_mul_annihilate _ rfl _
/-!
@ -151,9 +132,7 @@ lemma normalOrder_swap_create_annihlate_ofCrAnList_ofCrAnList (φc φa : 𝓕.Cr
normalOrder (ofCrAnList φs' * ofCrAnState φa * ofCrAnState φc * ofCrAnList φs) := by
rw [mul_assoc, mul_assoc, ← ofCrAnList_cons, ← ofCrAnList_cons, ← ofCrAnList_append]
rw [normalOrder_ofCrAnList, normalOrderSign_swap_create_annihlate φc φa hφc hφa]
rw [normalOrderList_swap_create_annihlate φc φa hφc hφa]
rw [← smul_smul, ← normalOrder_ofCrAnList]
congr
rw [normalOrderList_swap_create_annihlate φc φa hφc hφa, ← smul_smul, ← normalOrder_ofCrAnList]
rw [ofCrAnList_append, ofCrAnList_cons, ofCrAnList_cons]
noncomm_ring
@ -166,9 +145,7 @@ lemma normalOrder_swap_create_annihlate_ofCrAnList (φc φa : 𝓕.CrAnStates)
change (normalOrder ∘ₗ mulLinearMap (ofCrAnList φs * ofCrAnState φc * ofCrAnState φa)) a =
(smulLinearMap _ ∘ₗ normalOrder ∘ₗ
mulLinearMap (ofCrAnList φs * ofCrAnState φa * ofCrAnState φc)) a
refine LinearMap.congr_fun ?h a
apply ofCrAnListBasis.ext
intro l
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate_ofCrAnList_ofCrAnList φc φa hφc hφa]
@ -184,26 +161,20 @@ lemma normalOrder_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
change (normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φc * (ofCrAnState φa * b))) a =
(smulLinearMap (𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa)) ∘ₗ
normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φa * (ofCrAnState φc * b))) a
apply LinearMap.congr_fun
apply ofCrAnListBasis.ext
intro l
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) _
simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk, instCommGroup.eq_1]
repeat rw [← mul_assoc]
rw [normalOrder_swap_create_annihlate_ofCrAnList φc φa hφc hφa]
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk, instCommGroup.eq_1, ← mul_assoc,
normalOrder_swap_create_annihlate_ofCrAnList φc φa hφc hφa]
rfl
lemma normalOrder_superCommute_create_annihilate (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.CrAnAlgebra) :
normalOrder (a * superCommute (ofCrAnState φc) (ofCrAnState φa) * b) = 0 := by
rw [superCommute_ofCrAnState_ofCrAnState]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [mul_sub, sub_mul, map_sub, ← smul_mul_assoc]
rw [← mul_assoc, ← mul_assoc]
rw [normalOrder_swap_create_annihlate φc φa hφc hφa]
simp only [FieldStatistic.instCommGroup.eq_1, Algebra.mul_smul_comm, Algebra.smul_mul_assoc,
map_smul, sub_self]
simp only [superCommute_ofCrAnState_ofCrAnState, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [mul_sub, sub_mul, map_sub, ← smul_mul_assoc, ← mul_assoc, ← mul_assoc,
normalOrder_swap_create_annihlate φc φa hφc hφa]
simp
lemma normalOrder_superCommute_annihilate_create (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
@ -212,8 +183,7 @@ lemma normalOrder_superCommute_annihilate_create (φc φa : 𝓕.CrAnStates)
rw [superCommute_ofCrAnState_ofCrAnState_symm]
simp only [instCommGroup.eq_1, neg_smul, mul_neg, Algebra.mul_smul_comm, neg_mul,
Algebra.smul_mul_assoc, map_neg, map_smul, neg_eq_zero, smul_eq_zero]
apply Or.inr
exact normalOrder_superCommute_create_annihilate φc φa hφc hφa a b
exact Or.inr (normalOrder_superCommute_create_annihilate φc φa hφc hφa ..)
lemma normalOrder_swap_crPart_anPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
normalOrder (a * (crPart (StateAlgebra.ofState φ)) * (anPart (StateAlgebra.ofState φ')) * b) =
@ -221,34 +191,28 @@ lemma normalOrder_swap_crPart_anPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra
normalOrder (a * (anPart (StateAlgebra.ofState φ')) *
(crPart (StateAlgebra.ofState φ)) * b) := by
match φ, φ' with
| _, .inAsymp φ' =>
simp
| .outAsymp φ, _ =>
simp
| _, .inAsymp φ' => simp
| .outAsymp φ, _ => simp
| .position φ, .position φ' =>
simp only [crPart_position, anPart_position, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
rfl
rfl
rfl; rfl
| .inAsymp φ, .outAsymp φ' =>
simp only [crPart_negAsymp, anPart_posAsymp, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
rfl
rfl
rfl; rfl
| .inAsymp φ, .position φ' =>
simp only [crPart_negAsymp, anPart_position, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
rfl
rfl
rfl; rfl
| .position φ, .outAsymp φ' =>
simp only [crPart_position, anPart_posAsymp, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
rfl
rfl
rfl; rfl
/-!
@ -262,51 +226,45 @@ lemma normalOrder_swap_anPart_crPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra
normalOrder (a * (anPart (StateAlgebra.ofState φ)) * (crPart (StateAlgebra.ofState φ')) * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • normalOrder (a * (crPart (StateAlgebra.ofState φ')) *
(anPart (StateAlgebra.ofState φ)) * b) := by
rw [normalOrder_swap_crPart_anPart]
rw [smul_smul, FieldStatistic.exchangeSign_symm, FieldStatistic.exchangeSign_mul_self]
simp
simp [normalOrder_swap_crPart_anPart, smul_smul]
lemma normalOrder_superCommute_crPart_anPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
normalOrder (a * superCommute
(crPart (StateAlgebra.ofState φ)) (anPart (StateAlgebra.ofState φ')) * b) = 0 := by
match φ, φ' with
| _, .inAsymp φ' =>
simp
| .outAsymp φ', _ =>
simp
| _, .inAsymp φ' => simp
| .outAsymp φ', _ => simp
| .position φ, .position φ' =>
simp only [crPart_position, anPart_position]
refine normalOrder_superCommute_create_annihilate _ _ (by rfl) (by rfl) _ _
rw [crPart_position, anPart_position]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
| .inAsymp φ, .outAsymp φ' =>
simp only [crPart_negAsymp, anPart_posAsymp]
refine normalOrder_superCommute_create_annihilate _ _ (by rfl) (by rfl) _ _
rw [crPart_negAsymp, anPart_posAsymp]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
| .inAsymp φ, .position φ' =>
simp only [crPart_negAsymp, anPart_position]
refine normalOrder_superCommute_create_annihilate _ _ (by rfl) (by rfl) _ _
rw [crPart_negAsymp, anPart_position]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
| .position φ, .outAsymp φ' =>
simp only [crPart_position, anPart_posAsymp]
refine normalOrder_superCommute_create_annihilate _ _ (by rfl) (by rfl) _ _
rw [crPart_position, anPart_posAsymp]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
lemma normalOrder_superCommute_anPart_crPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
normalOrder (a * superCommute
(anPart (StateAlgebra.ofState φ)) (crPart (StateAlgebra.ofState φ')) * b) = 0 := by
match φ, φ' with
| .inAsymp φ', _ =>
simp
| _, .outAsymp φ' =>
simp
| .inAsymp φ', _ => simp
| _, .outAsymp φ' => simp
| .position φ, .position φ' =>
simp only [anPart_position, crPart_position]
refine normalOrder_superCommute_annihilate_create _ _ (by rfl) (by rfl) _ _
rw [anPart_position, crPart_position]
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
| .outAsymp φ', .inAsymp φ =>
simp only [anPart_posAsymp, crPart_negAsymp]
refine normalOrder_superCommute_annihilate_create _ _ (by rfl) (by rfl) _ _
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
| .position φ', .inAsymp φ =>
simp only [anPart_position, crPart_negAsymp]
refine normalOrder_superCommute_annihilate_create _ _ (by rfl) (by rfl) _ _
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
| .outAsymp φ, .position φ' =>
simp only [anPart_posAsymp, crPart_position]
refine normalOrder_superCommute_annihilate_create _ _ (by rfl) (by rfl) _ _
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
/-!
@ -359,8 +317,7 @@ lemma normalOrder_ofState_mul_ofState (φ φ' : 𝓕.States) :
(crPart (StateAlgebra.ofState φ') * anPart (StateAlgebra.ofState φ)) +
crPart (StateAlgebra.ofState φ) * anPart (StateAlgebra.ofState φ') +
anPart (StateAlgebra.ofState φ) * anPart (StateAlgebra.ofState φ') := by
rw [ofState_eq_crPart_add_anPart, ofState_eq_crPart_add_anPart]
rw [mul_add, add_mul, add_mul]
rw [ofState_eq_crPart_add_anPart, ofState_eq_crPart_add_anPart, mul_add, add_mul, add_mul]
simp only [map_add, normalOrder_crPart_mul_crPart, normalOrder_anPart_mul_crPart,
instCommGroup.eq_1, normalOrder_crPart_mul_anPart, normalOrder_anPart_mul_anPart]
abel
@ -381,17 +338,14 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
normalOrderSign (φs ++ φc' :: φc :: φs') •
(ofCrAnList (createFilter φs) * superCommute (ofCrAnState φc) (ofCrAnState φc') *
ofCrAnList (createFilter φs') * ofCrAnList (annihilateFilter (φs ++ φs'))) := by
rw [superCommute_ofCrAnState_ofCrAnState]
rw [mul_sub, sub_mul, map_sub]
rw [superCommute_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
conv_lhs =>
lhs
rhs
lhs; rhs
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append, ← ofCrAnList_append,
← ofCrAnList_append]
conv_lhs =>
lhs
rw [normalOrder_ofCrAnList]
rw [normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_create _ hφc, createFilter_singleton_create _ hφc']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -401,10 +355,8 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
instCommGroup.eq_1, Algebra.smul_mul_assoc, Algebra.mul_smul_comm, map_smul]
rw [← annihilateFilter_append]
conv_lhs =>
rhs
rhs
rw [smul_mul_assoc]
rw [Algebra.mul_smul_comm, smul_mul_assoc]
rhs; rhs
rw [smul_mul_assoc, Algebra.mul_smul_comm, smul_mul_assoc]
rhs
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append, ← ofCrAnList_append,
← ofCrAnList_append]
@ -412,8 +364,7 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
rhs
rw [map_smul]
rhs
rw [normalOrder_ofCrAnList]
rw [normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_create _ hφc, createFilter_singleton_create _ hφc']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -423,25 +374,20 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
List.append_nil, Algebra.smul_mul_assoc]
rw [← annihilateFilter_append]
conv_lhs =>
lhs
lhs
lhs; lhs
simp
conv_lhs =>
rhs
rhs
lhs
rhs; rhs; lhs
simp
rw [normalOrderSign_swap_create_create φc φc' hφc hφc']
rw [smul_smul, mul_comm, ← smul_smul]
rw [← smul_sub, ofCrAnList_append, ofCrAnList_append, ofCrAnList_append]
conv_lhs =>
rhs
rhs
rhs; rhs
rw [ofCrAnList_append, ofCrAnList_append, ofCrAnList_append]
rw [← smul_mul_assoc, ← smul_mul_assoc, ← Algebra.mul_smul_comm]
rw [← sub_mul, ← sub_mul, ← mul_sub]
congr
rw [ofCrAnList_append, ofCrAnList_singleton, ofCrAnList_singleton]
rw [← sub_mul, ← sub_mul, ← mul_sub, ofCrAnList_append, ofCrAnList_singleton,
ofCrAnList_singleton]
rw [ofCrAnList_append, ofCrAnList_singleton, ofCrAnList_singleton, smul_mul_assoc]
lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
@ -455,17 +401,14 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
(ofCrAnList (createFilter (φs ++ φs'))
* ofCrAnList (annihilateFilter φs) * superCommute (ofCrAnState φa) (ofCrAnState φa')
* ofCrAnList (annihilateFilter φs')) := by
rw [superCommute_ofCrAnState_ofCrAnState]
rw [mul_sub, sub_mul, map_sub]
rw [superCommute_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
conv_lhs =>
lhs
rhs
lhs; rhs
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append, ← ofCrAnList_append,
← ofCrAnList_append]
conv_lhs =>
lhs
rw [normalOrder_ofCrAnList]
rw [normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_annihilate _ hφa, createFilter_singleton_annihilate _ hφa']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -475,8 +418,7 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
instCommGroup.eq_1, Algebra.smul_mul_assoc, Algebra.mul_smul_comm, map_smul]
rw [← createFilter_append]
conv_lhs =>
rhs
rhs
rhs; rhs
rw [smul_mul_assoc]
rw [Algebra.mul_smul_comm, smul_mul_assoc]
rhs
@ -486,8 +428,7 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
rhs
rw [map_smul]
rhs
rw [normalOrder_ofCrAnList]
rw [normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_annihilate _ hφa, createFilter_singleton_annihilate _ hφa']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -497,20 +438,16 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
List.append_nil, Algebra.smul_mul_assoc]
rw [← createFilter_append]
conv_lhs =>
lhs
lhs
lhs; lhs
simp
conv_lhs =>
rhs
rhs
lhs
rhs; rhs; lhs
simp
rw [normalOrderSign_swap_annihilate_annihilate φa φa' hφa hφa']
rw [smul_smul, mul_comm, ← smul_smul]
rw [← smul_sub, ofCrAnList_append, ofCrAnList_append, ofCrAnList_append]
conv_lhs =>
rhs
rhs
rhs; rhs
rw [ofCrAnList_append, ofCrAnList_append, ofCrAnList_append]
rw [← Algebra.mul_smul_comm, ← smul_mul_assoc, ← Algebra.mul_smul_comm]
rw [← mul_sub, ← sub_mul, ← mul_sub]
@ -519,7 +456,6 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
apply congrArg
rw [mul_assoc]
apply congrArg
congr
rw [ofCrAnList_append, ofCrAnList_singleton, ofCrAnList_singleton]
rw [ofCrAnList_append, ofCrAnList_singleton, ofCrAnList_singleton, smul_mul_assoc]
@ -558,16 +494,14 @@ lemma ofCrAnList_mul_normalOrder_ofStateList_eq_superCommute (φs : List 𝓕.Cr
ofCrAnList φs * normalOrder (ofStateList φs') =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • normalOrder (ofStateList φs') * ofCrAnList φs
+ ⟨ofCrAnList φs, normalOrder (ofStateList φs')⟩ₛca := by
rw [ofCrAnList_superCommute_normalOrder_ofStateList]
simp
simp [ofCrAnList_superCommute_normalOrder_ofStateList]
lemma ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.States) :
ofCrAnState φ * normalOrder (ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • normalOrder (ofStateList φs') * ofCrAnState φ
+ ⟨ofCrAnState φ, normalOrder (ofStateList φs')⟩ₛca := by
rw [← ofCrAnList_singleton, ofCrAnList_mul_normalOrder_ofStateList_eq_superCommute]
simp [ofCrAnList_singleton]
simp [← ofCrAnList_singleton, ofCrAnList_mul_normalOrder_ofStateList_eq_superCommute]
lemma anPart_mul_normalOrder_ofStateList_eq_superCommute (φ : 𝓕.States)
(φs' : List 𝓕.States) :
@ -576,16 +510,9 @@ lemma anPart_mul_normalOrder_ofStateList_eq_superCommute (φ : 𝓕.States)
+ ⟨anPart (StateAlgebra.ofState φ), normalOrder (ofStateList φs')⟩ₛca := by
rw [normalOrder_mul_anPart]
match φ with
| .inAsymp φ =>
simp
| .position φ =>
simp only [anPart_position, instCommGroup.eq_1]
rw [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute]
simp [crAnStatistics]
| .outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1]
rw [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute]
simp [crAnStatistics]
| .inAsymp φ => simp
| .position φ => simp [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute, crAnStatistics]
| .outAsymp φ => simp [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute, crAnStatistics]
end

24
HepLean/PerturbationTheory/FieldSpecification/NormalOrder.lean
View file

@ -69,19 +69,14 @@ lemma koszulSignInsert_create (φ : 𝓕.CrAnStates)
lemma normalOrderSign_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
normalOrderSign (φ :: φs) = normalOrderSign φs := by
dsimp only [normalOrderSign, Wick.koszulSign]
rw [koszulSignInsert_create φ hφ φs]
simp
simp [normalOrderSign, Wick.koszulSign, koszulSignInsert_create φ hφ φs]
@[simp]
lemma normalOrderSign_singleton (φ : 𝓕.CrAnStates) :
normalOrderSign [φ] = 1 := by
lemma normalOrderSign_singleton (φ : 𝓕.CrAnStates) : normalOrderSign [φ] = 1 := by
simp [normalOrderSign]
@[simp]
lemma normalOrderSign_nil :
normalOrderSign (𝓕 := 𝓕) [] = 1 := by
simp [normalOrderSign, Wick.koszulSign]
lemma normalOrderSign_nil : normalOrderSign (𝓕 := 𝓕) [] = 1 := rfl
lemma koszulSignInsert_append_annihilate (φ' φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
@ -139,10 +134,8 @@ lemma normalOrderSign_swap_create_annihlate_fst (φc φa : 𝓕.CrAnStates)
lemma koszulSignInsert_swap (φ φc φa : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ (φs ++ φa :: φc :: φs')
= Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ (φs ++ φc :: φa :: φs') := by
apply Wick.koszulSignInsert_eq_perm
refine List.Perm.append_left φs ?h.a
exact List.Perm.swap φc φa φs'
= Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ (φs ++ φc :: φa :: φs') :=
Wick.koszulSignInsert_eq_perm _ _ _ _ _ (List.Perm.append_left φs (List.Perm.swap φc φa φs'))
lemma normalOrderSign_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate) :
@ -157,12 +150,9 @@ lemma normalOrderSign_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
rw [← mul_assoc, mul_comm _ (FieldStatistic.exchangeSign _ _), mul_assoc]
simp only [FieldStatistic.instCommGroup.eq_1, mul_eq_mul_left_iff]
apply Or.inl
conv_rhs =>
rw [normalOrderSign]
dsimp [Wick.koszulSign]
rw [← normalOrderSign]
conv_rhs => rw [normalOrderSign, Wick.koszulSign, ← normalOrderSign]
simp only [mul_eq_mul_right_iff]
apply Or.inl
left
rw [koszulSignInsert_swap]
lemma normalOrderSign_swap_create_create_fst (φc φc' : 𝓕.CrAnStates)

2
HepLean/PerturbationTheory/WickContraction/Insert.lean
View file

@ -200,7 +200,7 @@ lemma mem_uncontracted_insert_none_iff (c : WickContraction n) (i : Fin n.succ)
· simp only [Nat.succ_eq_add_one, ← Fin.exists_succAbove_eq_iff] at hi
obtain ⟨z, hk⟩ := hi
subst hk
have hn : ¬ i.succAbove z = i := by exact Fin.succAbove_ne i z
have hn : ¬ i.succAbove z = i := Fin.succAbove_ne i z
simp only [Nat.succ_eq_add_one, insert_succAbove_mem_uncontracted_iff, hn, false_or]
apply Iff.intro
· intro h

4
HepLean/PerturbationTheory/WickContraction/InsertList.lean
View file

@ -77,7 +77,7 @@ lemma insertList_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : List
· simp [congrLift]
· rw [Fin.lt_def] at h ⊢
simp_all only [Nat.succ_eq_add_one, Fin.val_fin_lt, not_lt, finCongr_apply, Fin.coe_cast]
have hi : i.succAbove j ≠ i := by exact Fin.succAbove_ne i j
have hi : i.succAbove j ≠ i := Fin.succAbove_ne i j
omega
/-!
@ -188,7 +188,7 @@ lemma insertList_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : List
· simp [congrLift]
· rw [Fin.lt_def] at h ⊢
simp_all only [Nat.succ_eq_add_one, Fin.val_fin_lt, not_lt, finCongr_apply, Fin.coe_cast]
have hi : i.succAbove j ≠ i := by exact Fin.succAbove_ne i j
have hi : i.succAbove j ≠ i := Fin.succAbove_ne i j
omega
lemma insertList_none_prod_contractions (φ : 𝓕.States) (φs : List 𝓕.States)

20
HepLean/PerturbationTheory/WickContraction/Sign.lean
View file

@ -240,7 +240,7 @@ lemma signFinset_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
simp_all only [and_true, Finset.mem_insert]
rw [succAbove_mem_insertListLiftFinset]
simp only [Fin.ext_iff, Fin.coe_cast]
have h1 : ¬ (i.succAbove ↑j) = i := by exact Fin.succAbove_ne i ↑j
have h1 : ¬ (i.succAbove ↑j) = i := Fin.succAbove_ne i ↑j
simp only [Fin.val_eq_val, h1, signFinset, Finset.mem_filter, Finset.mem_univ, true_and,
false_or]
rw [Fin.succAbove_lt_succAbove_iff, Fin.succAbove_lt_succAbove_iff]
@ -284,7 +284,7 @@ lemma signFinset_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
intro h
simp only [Fin.ext_iff, Fin.coe_cast] at h
simp only [Fin.val_eq_val] at h
have hn : ¬ i.succAbove k = i := by exact Fin.succAbove_ne i k
have hn : ¬ i.succAbove k = i := Fin.succAbove_ne i k
exact False.elim (hn h)
· split
simp only [Nat.succ_eq_add_one, finCongr_apply, Finset.mem_erase, ne_eq,
@ -807,7 +807,7 @@ lemma stat_signFinset_insert_some_self_fst
obtain ⟨y, hy1, hy2⟩ := h
simp only [Fin.ext_iff, Fin.coe_cast] at hy2
simp only [Fin.val_eq_val] at hy2
rw [Function.Injective.eq_iff (by exact Fin.succAbove_right_injective)] at hy2
rw [Function.Injective.eq_iff (Fin.succAbove_right_injective)] at hy2
subst hy2
simp only [hy1, true_and]
apply And.intro
@ -885,7 +885,7 @@ lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.States) (φs : List 𝓕.S
obtain ⟨y, hy1, hy2⟩ := h
simp only [Fin.ext_iff, Fin.coe_cast] at hy2
simp only [Fin.val_eq_val] at hy2
rw [Function.Injective.eq_iff (by exact Fin.succAbove_right_injective)] at hy2
rw [Function.Injective.eq_iff (Fin.succAbove_right_injective)] at hy2
subst hy2
simp only [hy1, true_and]
apply And.intro
@ -965,13 +965,13 @@ lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List
· exact h1'
· /- The `(c.getDual? i).isSome` case for `stat_ofFinset_eq_one_of_gradingCompliant`. -/
intro j hj
have hn : ¬ c.getDual? j = none := by exact Option.isSome_iff_ne_none.mp hj
have hn : ¬ c.getDual? j = none := Option.isSome_iff_ne_none.mp hj
simp only [uncontracted, Finset.mem_sdiff, Finset.mem_union, Finset.mem_filter, Finset.mem_univ,
hn, hj, forall_true_left, false_or, true_and, and_false, false_and, Finset.mem_inter,
not_false_eq_true, and_true, not_and, not_lt, getDual?_getDual?_get_get, reduceCtorEq,
Option.isSome_some, Option.get_some, forall_const, and_imp]
intro h1 h2
have hijsucc' : i.succAbove ((c.getDual? j).get hj) ≠ i := by exact Fin.succAbove_ne i _
have hijsucc' : i.succAbove ((c.getDual? j).get hj) ≠ i := Fin.succAbove_ne i _
have hkneqj : ↑k ≠ j := by
by_contra hkj
have hk := k.prop
@ -1025,7 +1025,7 @@ lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : L
signInsertSome φ φs c i k *
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, c.uncontracted.filter (fun x => x < ↑k)⟩)
= 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => i.succAbove x < i)⟩) := by
have hik : i.succAbove ↑k ≠ i := by exact Fin.succAbove_ne i ↑k
have hik : i.succAbove ↑k ≠ i := Fin.succAbove_ne i ↑k
rw [signInsertSome, signInsertSomeProd_eq_finset (hφj := hg.2) (hg := hg.1),
signInsertSomeCoef_eq_finset (hφj := hg.2), if_pos (by omega), ← map_mul, ← map_mul]
congr 1
@ -1036,7 +1036,7 @@ lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : L
apply stat_ofFinset_eq_one_of_gradingCompliant _ _ _ hg.1
· /- The `c.getDual? i = none` case for `stat_ofFinset_eq_one_of_gradingCompliant`. -/
intro j hj
have hijsucc : i.succAbove j ≠ i := by exact Fin.succAbove_ne i j
have hijsucc : i.succAbove j ≠ i := Fin.succAbove_ne i j
simp only [uncontracted, Finset.mem_sdiff, Finset.mem_union, Finset.mem_filter, Finset.mem_univ,
hj, Option.isSome_none, Bool.false_eq_true, IsEmpty.forall_iff, or_self, and_true, true_and,
and_false, or_false, Finset.mem_inter, not_false_eq_true, and_self, not_and, not_lt,
@ -1055,8 +1055,8 @@ lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : L
omega
· /- The `(c.getDual? i).isSome` case for `stat_ofFinset_eq_one_of_gradingCompliant`. -/
intro j hj
have hn : ¬ c.getDual? j = none := by exact Option.isSome_iff_ne_none.mp hj
have hijSuc : i.succAbove j ≠ i := by exact Fin.succAbove_ne i j
have hn : ¬ c.getDual? j = none := Option.isSome_iff_ne_none.mp hj
have hijSuc : i.succAbove j ≠ i := Fin.succAbove_ne i j
have hkneqj : ↑k ≠ j := by
by_contra hkj
have hk := k.prop

2
HepLean/PerturbationTheory/WicksTheorem.lean
View file

@ -198,7 +198,7 @@ lemma sign_timeContract_normalOrder_insertList_some (φ : 𝓕.States) (φs : Li
congr 1
exact signInsertSome_mul_filter_contracted_of_lt φ φs c i k hk hg
· omega
· have hik : i.succAbove ↑k ≠ i := by exact Fin.succAbove_ne i ↑k
· have hik : i.succAbove ↑k ≠ i := Fin.succAbove_ne i ↑k
rw [WickContraction.timeConract_insertList_some_eq_mul_contractStateAtIndex_lt]
swap
· exact hlt _