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

refactor: Rename ofStateList to ofFieldOpListF

Browse source
This commit is contained in:
jstoobysmith 2025-02-03 11:10:20 +00:00
parent b0735a1e13
commit 08260e709c
10 changed files with 126 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

14
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/Basic.lean
View file

@ -434,27 +434,27 @@ def ofFieldOp (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofState φ)
lemma ofFieldOp_eq_ι_ofState (φ : 𝓕.States) : ofFieldOp φ = ι (ofState φ) := rfl
/-- An element of `FieldOpAlgebra` from a list of `States`. -/
def ofFieldOpList (φs : List 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofStateList φs)
def ofFieldOpList (φs : List 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofFieldOpListF φs)
lemma ofFieldOpList_eq_ι_ofStateList (φs : List 𝓕.States) :
ofFieldOpList φs = ι (ofStateList φs) := rfl
lemma ofFieldOpList_eq_ι_ofFieldOpListF (φs : List 𝓕.States) :
ofFieldOpList φs = ι (ofFieldOpListF φs) := rfl
lemma ofFieldOpList_append (φs ψs : List 𝓕.States) :
ofFieldOpList (φs ++ ψs) = ofFieldOpList φs * ofFieldOpList ψs := by
simp only [ofFieldOpList]
rw [ofStateList_append]
rw [ofFieldOpListF_append]
simp
lemma ofFieldOpList_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
ofFieldOpList (φ :: φs) = ofFieldOp φ * ofFieldOpList φs := by
simp only [ofFieldOpList]
rw [ofStateList_cons]
rw [ofFieldOpListF_cons]
simp only [map_mul]
rfl
lemma ofFieldOpList_singleton (φ : 𝓕.States) :
ofFieldOpList [φ] = ofFieldOp φ := by
simp only [ofFieldOpList, ofFieldOp, ofStateList_singleton]
simp only [ofFieldOpList, ofFieldOp, ofFieldOpListF_singleton]
/-- An element of `FieldOpAlgebra` from a `CrAnStates`. -/
def ofCrAnFieldOp (φ : 𝓕.CrAnStates) : 𝓕.FieldOpAlgebra := ι (ofCrAnState φ)
@ -486,7 +486,7 @@ lemma ofCrAnFieldOpList_singleton (φ : 𝓕.CrAnStates) :
lemma ofFieldOpList_eq_sum (φs : List 𝓕.States) :
ofFieldOpList φs = ∑ s : CrAnSection φs, ofCrAnFieldOpList s.1 := by
rw [ofFieldOpList, ofStateList_sum]
rw [ofFieldOpList, ofFieldOpListF_sum]
simp only [map_sum]
rfl

4
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/NormalOrder.lean
View file

@ -409,7 +409,7 @@ lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝(ofFieldOpList φs' * anPart φ) +
[anPart φ, 𝓝(ofFieldOpList φs')]ₛ := by
rw [anPart, ofFieldOpList, normalOrder_eq_ι_normalOrderF, ← map_mul]
rw [anPartF_mul_normalOrderF_ofStateList_eq_superCommuteF]
rw [anPartF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF]
simp only [instCommGroup.eq_1, map_add, map_smul]
rfl
@ -520,7 +520,7 @@ lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
lhs
rw [← add_mul, ← ofFieldOp_eq_crPart_add_anPart]
/-- In the expansion of `ofState φ * normalOrderF (ofStateList φs)` the element
/-- In the expansion of `ofState φ * normalOrderF (ofFieldOpListF φs)` the element
of `𝓞.A` associated with contracting `φ` with the (optional) `n`th element of `φs`. -/
noncomputable def contractStateAtIndex (φ : 𝓕.States) (φs : List 𝓕.States)
(n : Option (Fin φs.length)) : 𝓕.FieldOpAlgebra :=

2
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/StaticWickTheorem.lean
View file

@ -23,7 +23,7 @@ namespace FieldOpAlgebra
lemma static_wick_theorem_nil : ofFieldOpList [] = ∑ (φsΛ : WickContraction [].length),
φsΛ.sign (𝓕 := 𝓕) • φsΛ.staticContract * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ) := by
simp only [ofFieldOpList, ofStateList_nil, map_one, List.length_nil]
simp only [ofFieldOpList, ofFieldOpListF_nil, map_one, List.length_nil]
rw [sum_WickContraction_nil, uncontractedListGet, nil_zero_uncontractedList]
simp [sign, empty, staticContract]

10
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/SuperCommute.lean
View file

@ -238,7 +238,7 @@ lemma superCommute_ofFieldOpList_ofFieldOpList (φs φs' : List 𝓕.States) :
[ofFieldOpList φs, ofFieldOpList φs']ₛ = ofFieldOpList φs * ofFieldOpList φs' -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofStateList_ofStatesList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofFieldOpListF_ofStatesList]
rfl
lemma superCommute_ofFieldOp_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
@ -252,7 +252,7 @@ lemma superCommute_ofFieldOpList_ofFieldOp (φs : List 𝓕.States) (φ : 𝓕.S
[ofFieldOpList φs, ofFieldOp φ]ₛ = ofFieldOpList φs * ofFieldOp φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOp φ * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofStateList_ofState]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofFieldOpListF_ofState]
rfl
lemma superCommute_anPart_crPart (φ φ' : 𝓕.States) :
@ -329,14 +329,14 @@ lemma superCommute_crPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.Stat
[crPart φ, ofFieldOpList φs]ₛ = crPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * crPart φ := by
rw [crPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofStateList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofFieldOpListF]
rfl
lemma superCommute_anPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPart φ, ofFieldOpList φs]ₛ = anPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * anPart φ := by
rw [anPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_ofStateList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_ofFieldOpListF]
rfl
lemma superCommute_crPart_ofFieldOp (φ φ' : 𝓕.States) :
@ -494,7 +494,7 @@ lemma superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum (φs : List 𝓕.CrAnS
ofFieldOpList (φs'.drop (n + 1)) := by
conv_lhs =>
rw [ofCrAnFieldOpList, ofFieldOpList, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnList_ofStateList_eq_sum]
superCommuteF_ofCrAnList_ofFieldOpListF_eq_sum]
rw [map_sum]
rfl

4
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/TimeOrder.lean
View file

@ -413,13 +413,13 @@ lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered_eq_timeOrder {φ ψ : 𝓕.State
rfl
lemma timeOrder_ofFieldOpList_nil : 𝓣(ofFieldOpList (𝓕 := 𝓕) []) = 1 := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofStateList_nil]
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofFieldOpListF_nil]
simp
@[simp]
lemma timeOrder_ofFieldOpList_singleton (φ : 𝓕.States) :
𝓣(ofFieldOpList [φ]) = ofFieldOpList [φ] := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofStateList_singleton]
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofFieldOpListF_singleton]
lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣(ofFieldOpList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,

28
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/Basic.lean
View file

@ -72,27 +72,27 @@ def ofState (φ : 𝓕.States) : FieldOpFreeAlgebra 𝓕 :=
/-- Maps a list of states to the creation and annihilation free-algebra by taking
the product of their sums of creation and annihlation operators.
Roughly `[φ1, φ2]` gets sent to `(φ1ᶜ+ φ1ᵃ) * (φ2ᶜ+ φ2ᵃ)` etc. -/
def ofStateList (φs : List 𝓕.States) : FieldOpFreeAlgebra 𝓕 := (List.map ofState φs).prod
def ofFieldOpListF (φs : List 𝓕.States) : FieldOpFreeAlgebra 𝓕 := (List.map ofState φs).prod
/-- Coercion from `List 𝓕.States` to `FieldOpFreeAlgebra 𝓕` through `ofStateList`. -/
instance : Coe (List 𝓕.States) (FieldOpFreeAlgebra 𝓕) := ⟨ofStateList⟩
/-- Coercion from `List 𝓕.States` to `FieldOpFreeAlgebra 𝓕` through `ofFieldOpListF`. -/
instance : Coe (List 𝓕.States) (FieldOpFreeAlgebra 𝓕) := ⟨ofFieldOpListF⟩
@[simp]
lemma ofStateList_nil : ofStateList ([] : List 𝓕.States) = 1 := rfl
lemma ofFieldOpListF_nil : ofFieldOpListF ([] : List 𝓕.States) = 1 := rfl
lemma ofStateList_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
ofStateList (φ :: φs) = ofState φ * ofStateList φs := rfl
lemma ofFieldOpListF_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
ofFieldOpListF (φ :: φs) = ofState φ * ofFieldOpListF φs := rfl
lemma ofStateList_singleton (φ : 𝓕.States) :
ofStateList [φ] = ofState φ := by simp [ofStateList]
lemma ofFieldOpListF_singleton (φ : 𝓕.States) :
ofFieldOpListF [φ] = ofState φ := by simp [ofFieldOpListF]
lemma ofStateList_append (φs φs' : List 𝓕.States) :
ofStateList (φs ++ φs') = ofStateList φs * ofStateList φs' := by
dsimp only [ofStateList]
lemma ofFieldOpListF_append (φs φs' : List 𝓕.States) :
ofFieldOpListF (φs ++ φs') = ofFieldOpListF φs * ofFieldOpListF φs' := by
dsimp only [ofFieldOpListF]
rw [List.map_append, List.prod_append]
lemma ofStateList_sum (φs : List 𝓕.States) :
ofStateList φs = ∑ (s : CrAnSection φs), ofCrAnList s.1 := by
lemma ofFieldOpListF_sum (φs : List 𝓕.States) :
ofFieldOpListF φs = ∑ (s : CrAnSection φs), ofCrAnList s.1 := by
induction φs with
| nil => simp
| cons φ φs ih =>
@ -101,7 +101,7 @@ lemma ofStateList_sum (φs : List 𝓕.States) :
conv_rhs =>
enter [2, x]
rw [← Finset.mul_sum]
rw [← Finset.sum_mul, ofStateList_cons, ← ih]
rw [← Finset.sum_mul, ofFieldOpListF_cons, ← ih]
rfl
/-!

42
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/NormalOrder.lean
View file

@ -527,11 +527,11 @@ lemma ofCrAnList_superCommuteF_normalOrderF_ofCrAnList (φs φs' : List 𝓕.CrA
simp [normalOrderF_ofCrAnList, map_smul, superCommuteF_ofCrAnList_ofCrAnList, ofCrAnList_append,
smul_sub, smul_smul, mul_comm]
lemma ofCrAnList_superCommuteF_normalOrderF_ofStateList (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, 𝓝ᶠ(ofStateList φs')]ₛca =
ofCrAnList φs * 𝓝ᶠ(ofStateList φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnList φs := by
rw [ofStateList_sum, map_sum, Finset.mul_sum, Finset.smul_sum, Finset.sum_mul,
lemma ofCrAnList_superCommuteF_normalOrderF_ofFieldOpListF (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, 𝓝ᶠ(ofFieldOpListF φs')]ₛca =
ofCrAnList φs * 𝓝ᶠ(ofFieldOpListF φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnList φs := by
rw [ofFieldOpListF_sum, map_sum, Finset.mul_sum, Finset.smul_sum, Finset.sum_mul,
← Finset.sum_sub_distrib, map_sum]
congr
funext n
@ -544,29 +544,29 @@ lemma ofCrAnList_superCommuteF_normalOrderF_ofStateList (φs : List 𝓕.CrAnSta
-/
lemma ofCrAnList_mul_normalOrderF_ofStateList_eq_superCommuteF (φs : List 𝓕.CrAnStates)
lemma ofCrAnList_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) :
ofCrAnList φs * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnList φs
+ [ofCrAnList φs, 𝓝ᶠ(ofStateList φs')]ₛca := by
simp [ofCrAnList_superCommuteF_normalOrderF_ofStateList]
ofCrAnList φs * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnList φs
+ [ofCrAnList φs, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by
simp [ofCrAnList_superCommuteF_normalOrderF_ofFieldOpListF]
lemma ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.States) : ofCrAnState φ * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnState φ
+ [ofCrAnState φ, 𝓝ᶠ(ofStateList φs')]ₛca := by
simp [← ofCrAnList_singleton, ofCrAnList_mul_normalOrderF_ofStateList_eq_superCommuteF]
lemma ofCrAnState_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.States) : ofCrAnState φ * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnState φ
+ [ofCrAnState φ, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by
simp [← ofCrAnList_singleton, ofCrAnList_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF]
lemma anPartF_mul_normalOrderF_ofStateList_eq_superCommuteF (φ : 𝓕.States)
lemma anPartF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.States)
(φs' : List 𝓕.States) :
anPartF φ * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs' * anPartF φ)
+ [anPartF φ, 𝓝ᶠ(ofStateList φs')]ₛca := by
anPartF φ * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs' * anPartF φ)
+ [anPartF φ, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by
rw [normalOrderF_mul_anPartF]
match φ with
| .inAsymp φ => simp
| .position φ => simp [ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF, crAnStatistics]
| .outAsymp φ => simp [ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF, crAnStatistics]
| .position φ => simp [ofCrAnState_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF, crAnStatistics]
| .outAsymp φ => simp [ofCrAnState_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF, crAnStatistics]
end

108
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/SuperCommute.lean
View file

@ -58,22 +58,22 @@ lemma superCommuteF_ofCrAnState_ofCrAnState (φ φ' : 𝓕.CrAnStates) :
rw [FieldStatistic.ofList_singleton, FieldStatistic.ofList_singleton, smul_mul_assoc]
lemma superCommuteF_ofCrAnList_ofStatesList (φcas : List 𝓕.CrAnStates) (φs : List 𝓕.States) :
[ofCrAnList φcas, ofStateList φs]ₛca = ofCrAnList φcas * ofStateList φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofStateList φs * ofCrAnList φcas := by
conv_lhs => rw [ofStateList_sum]
[ofCrAnList φcas, ofFieldOpListF φs]ₛca = ofCrAnList φcas * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofCrAnList φcas := by
conv_lhs => rw [ofFieldOpListF_sum]
rw [map_sum]
conv_lhs =>
enter [2, x]
rw [superCommuteF_ofCrAnList_ofCrAnList, CrAnSection.statistics_eq_state_statistics,
ofCrAnList_append, ofCrAnList_append]
rw [Finset.sum_sub_distrib, ← Finset.mul_sum, ← Finset.smul_sum,
← Finset.sum_mul, ← ofStateList_sum]
← Finset.sum_mul, ← ofFieldOpListF_sum]
simp
lemma superCommuteF_ofStateList_ofStatesList (φ : List 𝓕.States) (φs : List 𝓕.States) :
[ofStateList φ, ofStateList φs]ₛca = ofStateList φ * ofStateList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs * ofStateList φ := by
conv_lhs => rw [ofStateList_sum]
lemma superCommuteF_ofFieldOpListF_ofStatesList (φ : List 𝓕.States) (φs : List 𝓕.States) :
[ofFieldOpListF φ, ofFieldOpListF φs]ₛca = ofFieldOpListF φ * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofFieldOpListF φ := by
conv_lhs => rw [ofFieldOpListF_sum]
simp only [map_sum, LinearMap.coeFn_sum, Finset.sum_apply, instCommGroup.eq_1,
Algebra.smul_mul_assoc]
conv_lhs =>
@ -81,18 +81,18 @@ lemma superCommuteF_ofStateList_ofStatesList (φ : List 𝓕.States) (φs : List
rw [superCommuteF_ofCrAnList_ofStatesList]
simp only [instCommGroup.eq_1, CrAnSection.statistics_eq_state_statistics,
Algebra.smul_mul_assoc, Finset.sum_sub_distrib]
rw [← Finset.sum_mul, ← Finset.smul_sum, ← Finset.mul_sum, ← ofStateList_sum]
rw [← Finset.sum_mul, ← Finset.smul_sum, ← Finset.mul_sum, ← ofFieldOpListF_sum]
lemma superCommuteF_ofState_ofStatesList (φ : 𝓕.States) (φs : List 𝓕.States) :
[ofState φ, ofStateList φs]ₛca = ofState φ * ofStateList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs * ofState φ := by
rw [← ofStateList_singleton, superCommuteF_ofStateList_ofStatesList, ofStateList_singleton]
[ofState φ, ofFieldOpListF φs]ₛca = ofState φ * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofState φ := by
rw [← ofFieldOpListF_singleton, superCommuteF_ofFieldOpListF_ofStatesList, ofFieldOpListF_singleton]
simp
lemma superCommuteF_ofStateList_ofState (φs : List 𝓕.States) (φ : 𝓕.States) :
[ofStateList φs, ofState φ]ₛca = ofStateList φs * ofState φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofStateList φs := by
rw [← ofStateList_singleton, superCommuteF_ofStateList_ofStatesList, ofStateList_singleton]
lemma superCommuteF_ofFieldOpListF_ofState (φs : List 𝓕.States) (φ : 𝓕.States) :
[ofFieldOpListF φs, ofState φ]ₛca = ofFieldOpListF φs * ofState φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofFieldOpListF φs := by
rw [← ofFieldOpListF_singleton, superCommuteF_ofFieldOpListF_ofStatesList, ofFieldOpListF_singleton]
simp
lemma superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) :
@ -202,9 +202,9 @@ lemma superCommuteF_anPartF_anPartF (φ φ' : 𝓕.States) :
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
lemma superCommuteF_crPartF_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[crPartF φ, ofStateList φs]ₛca =
crPartF φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs *
lemma superCommuteF_crPartF_ofFieldOpListF (φ : 𝓕.States) (φs : List 𝓕.States) :
[crPartF φ, ofFieldOpListF φs]ₛca =
crPartF φ * ofFieldOpListF φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs *
crPartF φ := by
match φ with
| States.inAsymp φ =>
@ -218,10 +218,10 @@ lemma superCommuteF_crPartF_ofStateList (φ : 𝓕.States) (φs : List 𝓕.Stat
| States.outAsymp φ =>
simp
lemma superCommuteF_anPartF_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPartF φ, ofStateList φs]ₛca =
anPartF φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) •
ofStateList φs * anPartF φ := by
lemma superCommuteF_anPartF_ofFieldOpListF (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPartF φ, ofFieldOpListF φs]ₛca =
anPartF φ * ofFieldOpListF φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) •
ofFieldOpListF φs * anPartF φ := by
match φ with
| States.inAsymp φ =>
simp
@ -238,14 +238,14 @@ lemma superCommuteF_crPartF_ofState (φ φ' : 𝓕.States) :
[crPartF φ, ofState φ']ₛca =
crPartF φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * crPartF φ := by
rw [← ofStateList_singleton, superCommuteF_crPartF_ofStateList]
rw [← ofFieldOpListF_singleton, superCommuteF_crPartF_ofFieldOpListF]
simp
lemma superCommuteF_anPartF_ofState (φ φ' : 𝓕.States) :
[anPartF φ, ofState φ']ₛca =
anPartF φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * anPartF φ := by
rw [← ofStateList_singleton, superCommuteF_anPartF_ofStateList]
rw [← ofFieldOpListF_singleton, superCommuteF_anPartF_ofFieldOpListF]
simp
/-!
@ -268,22 +268,22 @@ lemma ofCrAnState_mul_ofCrAnList_eq_superCommuteF (φ : 𝓕.CrAnStates) (φs' :
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommuteF]
simp
lemma ofStateList_mul_ofStateList_eq_superCommuteF (φs φs' : List 𝓕.States) :
ofStateList φs * ofStateList φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofStateList φs' * ofStateList φs
+ [ofStateList φs, ofStateList φs']ₛca := by
rw [superCommuteF_ofStateList_ofStatesList]
lemma ofFieldOpListF_mul_ofFieldOpListF_eq_superCommuteF (φs φs' : List 𝓕.States) :
ofFieldOpListF φs * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofFieldOpListF φs
+ [ofFieldOpListF φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofFieldOpListF_ofStatesList]
simp
lemma ofState_mul_ofStateList_eq_superCommuteF (φ : 𝓕.States) (φs' : List 𝓕.States) :
ofState φ * ofStateList φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofStateList φs' * ofState φ
+ [ofState φ, ofStateList φs']ₛca := by
lemma ofState_mul_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.States) (φs' : List 𝓕.States) :
ofState φ * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofState φ
+ [ofState φ, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofState_ofStatesList]
simp
lemma ofStateList_mul_ofState_eq_superCommuteF (φs : List 𝓕.States) (φ : 𝓕.States) :
ofStateList φs * ofState φ = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofStateList φs
+ [ofStateList φs, ofState φ]ₛca := by
rw [superCommuteF_ofStateList_ofState]
lemma ofFieldOpListF_mul_ofState_eq_superCommuteF (φs : List 𝓕.States) (φ : 𝓕.States) :
ofFieldOpListF φs * ofState φ = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofFieldOpListF φs
+ [ofFieldOpListF φs, ofState φ]ₛca := by
rw [superCommuteF_ofFieldOpListF_ofState]
simp
lemma crPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
@ -314,9 +314,9 @@ lemma anPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
rw [superCommuteF_anPartF_anPartF]
simp
lemma ofCrAnList_mul_ofStateList_eq_superCommuteF (φs : List 𝓕.CrAnStates) (φs' : List 𝓕.States) :
ofCrAnList φs * ofStateList φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofStateList φs' * ofCrAnList φs
+ [ofCrAnList φs, ofStateList φs']ₛca := by
lemma ofCrAnList_mul_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnStates) (φs' : List 𝓕.States) :
ofCrAnList φs * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofCrAnList φs
+ [ofCrAnList φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofCrAnList_ofStatesList]
simp
@ -377,24 +377,24 @@ lemma superCommuteF_ofCrAnList_ofCrAnList_cons (φ : 𝓕.CrAnStates) (φs φs'
rw [← ofCrAnList_cons, smul_smul, FieldStatistic.ofList_cons_eq_mul]
simp only [instCommGroup, map_mul, mul_comm]
lemma superCommuteF_ofCrAnList_ofStateList_cons (φ : 𝓕.States) (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, ofStateList (φ :: φs')]ₛca =
[ofCrAnList φs, ofState φ]ₛca * ofStateList φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * [ofCrAnList φs, ofStateList φs']ₛca := by
lemma superCommuteF_ofCrAnList_ofFieldOpListF_cons (φ : 𝓕.States) (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, ofFieldOpListF (φ :: φs')]ₛca =
[ofCrAnList φs, ofState φ]ₛca * ofFieldOpListF φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * [ofCrAnList φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofCrAnList_ofStatesList]
conv_rhs =>
lhs
rw [← ofStateList_singleton, superCommuteF_ofCrAnList_ofStatesList, sub_mul, mul_assoc,
← ofStateList_append]
rw [← ofFieldOpListF_singleton, superCommuteF_ofCrAnList_ofStatesList, sub_mul, mul_assoc,
← ofFieldOpListF_append]
rhs
rw [FieldStatistic.ofList_singleton, ofStateList_singleton, smul_mul_assoc,
rw [FieldStatistic.ofList_singleton, ofFieldOpListF_singleton, smul_mul_assoc,
smul_mul_assoc, mul_assoc]
conv_rhs =>
rhs
rw [superCommuteF_ofCrAnList_ofStatesList, mul_sub, smul_mul_assoc]
simp only [instCommGroup, Algebra.smul_mul_assoc, List.singleton_append, Algebra.mul_smul_comm,
sub_add_sub_cancel, sub_right_inj]
rw [ofStateList_cons, mul_assoc, smul_smul, FieldStatistic.ofList_cons_eq_mul]
rw [ofFieldOpListF_cons, mul_assoc, smul_smul, FieldStatistic.ofList_cons_eq_mul]
simp [mul_comm]
/--
@ -417,23 +417,23 @@ lemma superCommuteF_ofCrAnList_ofCrAnList_eq_sum (φs : List 𝓕.CrAnStates) :
· simp [Finset.mul_sum, smul_smul, ofCrAnList_cons, mul_assoc,
FieldStatistic.ofList_cons_eq_mul, mul_comm]
lemma superCommuteF_ofCrAnList_ofStateList_eq_sum (φs : List 𝓕.CrAnStates) : (φs' : List 𝓕.States) →
[ofCrAnList φs, ofStateList φs']ₛca =
lemma superCommuteF_ofCrAnList_ofFieldOpListF_eq_sum (φs : List 𝓕.CrAnStates) : (φs' : List 𝓕.States) →
[ofCrAnList φs, ofFieldOpListF φs']ₛca =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofStateList (φs'.take n) * [ofCrAnList φs, ofState (φs'.get n)]ₛca *
ofStateList (φs'.drop (n + 1))
ofFieldOpListF (φs'.take n) * [ofCrAnList φs, ofState (φs'.get n)]ₛca *
ofFieldOpListF (φs'.drop (n + 1))
| [] => by
simp only [superCommuteF_ofCrAnList_ofStatesList, instCommGroup, ofList_empty,
exchangeSign_bosonic, one_smul, List.length_nil, Finset.univ_eq_empty, List.take_nil,
List.get_eq_getElem, List.drop_nil, Finset.sum_empty]
simp
| φ :: φs' => by
rw [superCommuteF_ofCrAnList_ofStateList_cons,
superCommuteF_ofCrAnList_ofStateList_eq_sum φs φs']
rw [superCommuteF_ofCrAnList_ofFieldOpListF_cons,
superCommuteF_ofCrAnList_ofFieldOpListF_eq_sum φs φs']
conv_rhs => erw [Fin.sum_univ_succ]
congr 1
· simp
· simp [Finset.mul_sum, smul_smul, ofStateList_cons, mul_assoc,
· simp [Finset.mul_sum, smul_smul, ofFieldOpListF_cons, mul_assoc,
FieldStatistic.ofList_cons_eq_mul, mul_comm]
lemma summerCommute_jacobi_ofCrAnList (φs1 φs2 φs3 : List 𝓕.CrAnStates) :

38
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/TimeOrder.lean
View file

@ -99,41 +99,41 @@ lemma timeOrderF_timeOrderF_left (a b : 𝓕.FieldOpFreeAlgebra) : 𝓣ᶠ(a * b
· rw [timeOrderF_timeOrderF_mid]
simp
lemma timeOrderF_ofStateList (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList φs) = timeOrderSign φs • ofStateList (timeOrderList φs) := by
lemma timeOrderF_ofFieldOpListF (φs : List 𝓕.States) :
𝓣ᶠ(ofFieldOpListF φs) = timeOrderSign φs • ofFieldOpListF (timeOrderList φs) := by
conv_lhs =>
rw [ofStateList_sum, map_sum]
rw [ofFieldOpListF_sum, map_sum]
enter [2, x]
rw [timeOrderF_ofCrAnList]
simp only [crAnTimeOrderSign_crAnSection]
rw [← Finset.smul_sum]
congr
rw [ofStateList_sum, sum_crAnSections_timeOrder]
rw [ofFieldOpListF_sum, sum_crAnSections_timeOrder]
rfl
lemma timeOrderF_ofStateList_nil : timeOrderF (𝓕 := 𝓕) (ofStateList []) = 1 := by
rw [timeOrderF_ofStateList]
lemma timeOrderF_ofFieldOpListF_nil : timeOrderF (𝓕 := 𝓕) (ofFieldOpListF []) = 1 := by
rw [timeOrderF_ofFieldOpListF]
simp [timeOrderSign, Wick.koszulSign, timeOrderList]
@[simp]
lemma timeOrderF_ofStateList_singleton (φ : 𝓕.States) : 𝓣ᶠ(ofStateList [φ]) = ofStateList [φ] := by
simp [timeOrderF_ofStateList, timeOrderSign, timeOrderList]
lemma timeOrderF_ofFieldOpListF_singleton (φ : 𝓕.States) : 𝓣ᶠ(ofFieldOpListF [φ]) = ofFieldOpListF [φ] := by
simp [timeOrderF_ofFieldOpListF, timeOrderSign, timeOrderList]
lemma timeOrderF_ofState_ofState_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
𝓣ᶠ(ofState φ * ofState ψ) = ofState φ * ofState ψ := by
rw [← ofStateList_singleton, ← ofStateList_singleton, ← ofStateList_append,
timeOrderF_ofStateList]
rw [← ofFieldOpListF_singleton, ← ofFieldOpListF_singleton, ← ofFieldOpListF_append,
timeOrderF_ofFieldOpListF]
simp only [List.singleton_append]
rw [timeOrderSign_pair_ordered h, timeOrderList_pair_ordered h]
simp
lemma timeOrderF_ofState_ofState_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
𝓣ᶠ(ofState φ * ofState ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • ofState ψ * ofState φ := by
rw [← ofStateList_singleton, ← ofStateList_singleton,
← ofStateList_append, timeOrderF_ofStateList]
rw [← ofFieldOpListF_singleton, ← ofFieldOpListF_singleton,
← ofFieldOpListF_append, timeOrderF_ofFieldOpListF]
simp only [List.singleton_append, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [timeOrderSign_pair_not_ordered h, timeOrderList_pair_not_ordered h]
simp [← ofStateList_append]
simp [← ofFieldOpListF_append]
lemma timeOrderF_ofState_ofState_not_ordered_eq_timeOrderF {φ ψ : 𝓕.States}
(h : ¬ timeOrderRel φ ψ) :
@ -298,11 +298,11 @@ lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_eq_time
where `φᵢ` is the state
which has maximum time and `s` is the exchange sign of `φᵢ` and `φ₀φ₁…φᵢ₋₁`. -/
lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList (φ :: φs)) =
𝓣ᶠ(ofFieldOpListF (φ :: φs)) =
𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ (φ :: φs).take (maxTimeFieldPos φ φs)) •
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofStateList (eraseMaxTimeField φ φs)) := by
rw [timeOrderF_ofStateList, timeOrderList_eq_maxTimeField_timeOrderList]
rw [ofStateList_cons, timeOrderF_ofStateList]
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofFieldOpListF (eraseMaxTimeField φ φs)) := by
rw [timeOrderF_ofFieldOpListF, timeOrderList_eq_maxTimeField_timeOrderList]
rw [ofFieldOpListF_cons, timeOrderF_ofFieldOpListF]
simp only [instCommGroup.eq_1, Algebra.mul_smul_comm, Algebra.smul_mul_assoc, smul_smul]
congr
rw [timerOrderSign_of_eraseMaxTimeField, mul_assoc]
@ -313,10 +313,10 @@ lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States)
which has maximum time and `s` is the exchange sign of `φᵢ` and `φ₀φ₁…φᵢ₋₁`.
Here `s` is written using finite sets. -/
lemma timeOrderF_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
𝓣ᶠ(ofFieldOpListF (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
(Finset.filter (fun x =>
(maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs) Finset.univ)⟩) •
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofStateList (eraseMaxTimeField φ φs)) := by
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofFieldOpListF (eraseMaxTimeField φ φs)) := by
rw [timeOrderF_eq_maxTimeField_mul]
congr 3
apply FieldStatistic.ofList_perm

2
HepLean/PerturbationTheory/FieldSpecification/CrAnSection.lean
View file

@ -22,7 +22,7 @@ That is to say, the states underlying `ψs` are the states in `φs`.
We denote these sections as `CrAnSection φs`.
Looking forward the main consequence of this definition is the lemma
`FieldSpecification.FieldOpFreeAlgebra.ofStateList_sum`.
`FieldSpecification.FieldOpFreeAlgebra.ofFieldOpListF_sum`.
In this module we define various properties of `CrAnSection`.