refactor: Rename ofStateList to ofFieldOpListF

2025-02-03 11:10:20 +00:00 · 2025-02-03 11:10:20 +00:00 · 08260e709c
commit 08260e709c
parent b0735a1e13
10 changed files with 126 additions and 126 deletions
--- a/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/Basic.lean
+++ b/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/Basic.lean
@ -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

 /-!
--- a/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/NormalOrder.lean
+++ b/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/NormalOrder.lean
@ -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

--- a/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/SuperCommute.lean
+++ b/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/SuperCommute.lean
@ -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) :
--- a/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/TimeOrder.lean
+++ b/HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/TimeOrder.lean
@ -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