diff --git a/HepLean/PerturbationTheory/WickContraction/InsertList.lean b/HepLean/PerturbationTheory/WickContraction/InsertList.lean
index ec03370..28a0aea 100644
--- a/HepLean/PerturbationTheory/WickContraction/InsertList.lean
+++ b/HepLean/PerturbationTheory/WickContraction/InsertList.lean
@@ -29,38 +29,38 @@ open HepLean.Fin
   `j : Option (c.uncontracted)` of `c`.
   The Wick contraction associated with `(φs.insertIdx i φ).length` formed by 'inserting' `φ`
   into `φs` after the first `i` elements and contracting it optionally with j. -/
-def insertList (φ : 𝓕.States) {φs : List 𝓕.States}
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option (c.uncontracted)) :
+def insertList (φ : 𝓕.States) {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : Option φsΛ.uncontracted) :
     WickContraction (φs.insertIdx i φ).length :=
-    congr (by simp) (c.insert i j)
+  congr (by simp) (φsΛ.insert i j)
 
 @[simp]
 lemma insertList_fstFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option (c.uncontracted))
-    (a : c.1) : (c.insertList φ i j).fstFieldOfContract
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option φsΛ.uncontracted)
+    (a : φsΛ.1) : (φsΛ.insertList φ i j).fstFieldOfContract
     (congrLift (insertIdx_length_fin φ φs i).symm (insertLift i j a)) =
-    finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove (c.fstFieldOfContract a)) := by
+    finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove (φsΛ.fstFieldOfContract a)) := by
   simp [insertList]
 
 @[simp]
 lemma insertList_sndFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option (c.uncontracted))
-    (a : c.1) : (c.insertList φ i j).sndFieldOfContract
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option (φsΛ.uncontracted))
+    (a : φsΛ.1) : (φsΛ.insertList φ i j).sndFieldOfContract
     (congrLift (insertIdx_length_fin φ φs i).symm (insertLift i j a)) =
-    finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove (c.sndFieldOfContract a)) := by
+    finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove (φsΛ.sndFieldOfContract a)) := by
   simp [insertList]
 
 @[simp]
 lemma insertList_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-      (insertList φ c i (some j)).fstFieldOfContract
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+      (insertList φ φsΛ i (some j)).fstFieldOfContract
       (congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩) =
       if i < i.succAbove j.1 then
       finCongr (insertIdx_length_fin φ φs i).symm i else
       finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j.1) := by
   split
   · rename_i h
-    refine (insertList φ c i (some j)).eq_fstFieldOfContract_of_mem
+    refine (insertList φ φsΛ i (some j)).eq_fstFieldOfContract_of_mem
       (a := congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩)
       (i := finCongr (insertIdx_length_fin φ φs i).symm i) (j :=
         finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j)) ?_ ?_ ?_
@@ -69,7 +69,7 @@ lemma insertList_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 
     · rw [Fin.lt_def] at h ⊢
       simp_all
   · rename_i h
-    refine (insertList φ c i (some j)).eq_fstFieldOfContract_of_mem
+    refine (insertList φ φsΛ i (some j)).eq_fstFieldOfContract_of_mem
       (a := congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩)
       (i := finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
       (j := finCongr (insertIdx_length_fin φ φs i).symm i) ?_ ?_ ?_
@@ -87,36 +87,36 @@ lemma insertList_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 
 -/
 @[simp]
 lemma insertList_none_getDual?_self (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) :
-    (insertList φ c i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm i) = none := by
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
+    (insertList φ φsΛ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm i) = none := by
   simp only [Nat.succ_eq_add_one, insertList, getDual?_congr, finCongr_apply, Fin.cast_trans,
     Fin.cast_eq_self, Option.map_eq_none']
-  have h1 := c.insert_none_getDual?_isNone i
+  have h1 := φsΛ.insert_none_getDual?_isNone i
   simpa using h1
 
 lemma insertList_isSome_getDual?_self (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    ((insertList φ c i (some j)).getDual?
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    ((insertList φ φsΛ i (some j)).getDual?
     (Fin.cast (insertIdx_length_fin φ φs i).symm i)).isSome := by
   simp [insertList, getDual?_congr]
 
 lemma insertList_some_getDual?_self_not_none (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    ¬ ((insertList φ c i (some j)).getDual?
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    ¬ ((insertList φ φsΛ i (some j)).getDual?
     (Fin.cast (insertIdx_length_fin φ φs i).symm i)) = none := by
   simp [insertList, getDual?_congr]
 
 @[simp]
 lemma insertList_some_getDual?_self_eq (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    ((insertList φ c i (some j)).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm i))
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    ((insertList φ φsΛ i (some j)).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm i))
     = some (Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove j)) := by
   simp [insertList, getDual?_congr]
 
 @[simp]
 lemma insertList_some_getDual?_some_eq (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    ((insertList φ c i (some j)).getDual?
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    ((insertList φ φsΛ i (some j)).getDual?
       (Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove j)))
     = some (Fin.cast (insertIdx_length_fin φ φs i).symm i) := by
   rw [getDual?_eq_some_iff_mem]
@@ -126,52 +126,52 @@ lemma insertList_some_getDual?_some_eq (φ : 𝓕.States) (φs : List 𝓕.State
 
 @[simp]
 lemma insertList_none_succAbove_getDual?_eq_none_iff (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
-    (insertList φ c i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
-      (i.succAbove j)) = none ↔ c.getDual? j = none := by
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
+    (insertList φ φsΛ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
+      (i.succAbove j)) = none ↔ φsΛ.getDual? j = none := by
   simp [insertList, getDual?_congr]
 
 @[simp]
 lemma insertList_some_succAbove_getDual?_eq_option (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
-    (k : c.uncontracted) (hkj : j ≠ k.1) :
-    (insertList φ c i (some k)).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
+    (k : φsΛ.uncontracted) (hkj : j ≠ k.1) :
+    (insertList φ φsΛ i (some k)).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
     (i.succAbove j)) = Option.map (Fin.cast (insertIdx_length_fin φ φs i).symm ∘ i.succAbove)
-    (c.getDual? j) := by
+    (φsΛ.getDual? j) := by
   simp only [Nat.succ_eq_add_one, insertList, getDual?_congr, finCongr_apply, Fin.cast_trans,
     Fin.cast_eq_self, ne_eq, hkj, not_false_eq_true, insert_some_getDual?_of_neq, Option.map_map]
   rfl
 
 @[simp]
 lemma insertList_none_succAbove_getDual?_isSome_iff (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
-    ((insertList φ c i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
-      (i.succAbove j))).isSome ↔ (c.getDual? j).isSome := by
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
+    ((insertList φ φsΛ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
+      (i.succAbove j))).isSome ↔ (φsΛ.getDual? j).isSome := by
   rw [← not_iff_not]
   simp
 
 @[simp]
 lemma insertList_none_getDual?_get_eq (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
-    (h : ((insertList φ c i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
+    (h : ((insertList φ φsΛ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
     (i.succAbove j))).isSome) :
-    ((insertList φ c i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
+    ((insertList φ φsΛ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
     (i.succAbove j))).get h = Fin.cast (insertIdx_length_fin φ φs i).symm
-    (i.succAbove ((c.getDual? j).get (by simpa using h))) := by
+    (i.succAbove ((φsΛ.getDual? j).get (by simpa using h))) := by
   simp [insertList, getDual?_congr_get]
 
 /-........................................... -/
 @[simp]
 lemma insertList_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    (insertList φ c i (some j)).sndFieldOfContract
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    (insertList φ φsΛ i (some j)).sndFieldOfContract
     (congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩) =
     if i < i.succAbove j.1 then
     finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j.1) else
     finCongr (insertIdx_length_fin φ φs i).symm i := by
   split
   · rename_i h
-    refine (insertList φ c i (some j)).eq_sndFieldOfContract_of_mem
+    refine (insertList φ φsΛ i (some j)).eq_sndFieldOfContract_of_mem
       (a := congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩)
       (i := finCongr (insertIdx_length_fin φ φs i).symm i) (j :=
         finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j)) ?_ ?_ ?_
@@ -180,7 +180,7 @@ lemma insertList_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 
     · rw [Fin.lt_def] at h ⊢
       simp_all
   · rename_i h
-    refine (insertList φ c i (some j)).eq_sndFieldOfContract_of_mem
+    refine (insertList φ φsΛ i (some j)).eq_sndFieldOfContract_of_mem
       (a := congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by simp [insert]⟩)
       (i := finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
       (j := finCongr (insertIdx_length_fin φ φs i).symm i) ?_ ?_ ?_
@@ -192,27 +192,27 @@ lemma insertList_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 
       omega
 
 lemma insertList_none_prod_contractions (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ)
-    (f : (c.insertList φ i none).1 → M) [CommMonoid M] :
-    ∏ a, f a = ∏ (a : c.1), f (congrLift (insertIdx_length_fin φ φs i).symm
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ)
+    (f : (φsΛ.insertList φ i none).1 → M) [CommMonoid M] :
+    ∏ a, f a = ∏ (a : φsΛ.1), f (congrLift (insertIdx_length_fin φ φs i).symm
       (insertLift i none a)) := by
-  let e1 := Equiv.ofBijective (c.insertLift i none) (insertLift_none_bijective i)
+  let e1 := Equiv.ofBijective (φsΛ.insertLift i none) (insertLift_none_bijective i)
   let e2 := Equiv.ofBijective (congrLift (insertIdx_length_fin φ φs i).symm)
-    ((c.insert i none).congrLift_bijective ((insertIdx_length_fin φ φs i).symm))
+    ((φsΛ.insert i none).congrLift_bijective ((insertIdx_length_fin φ φs i).symm))
   erw [← e2.prod_comp]
   erw [← e1.prod_comp]
   rfl
 
 lemma insertList_some_prod_contractions (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted)
-    (f : (c.insertList φ i (some j)).1 → M) [CommMonoid M] :
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted)
+    (f : (φsΛ.insertList φ i (some j)).1 → M) [CommMonoid M] :
     ∏ a, f a = f (congrLift (insertIdx_length_fin φ φs i).symm
       ⟨{i, i.succAbove j}, by simp [insert]⟩) *
-    ∏ (a : c.1), f (congrLift (insertIdx_length_fin φ φs i).symm (insertLift i (some j) a)) := by
+    ∏ (a : φsΛ.1), f (congrLift (insertIdx_length_fin φ φs i).symm (insertLift i (some j) a)) := by
   let e2 := Equiv.ofBijective (congrLift (insertIdx_length_fin φ φs i).symm)
-    ((c.insert i (some j)).congrLift_bijective ((insertIdx_length_fin φ φs i).symm))
+    ((φsΛ.insert i (some j)).congrLift_bijective ((insertIdx_length_fin φ φs i).symm))
   erw [← e2.prod_comp]
-  let e1 := Equiv.ofBijective (c.insertLiftSome i j) (insertLiftSome_bijective i j)
+  let e1 := Equiv.ofBijective (φsΛ.insertLiftSome i j) (insertLiftSome_bijective i j)
   erw [← e1.prod_comp]
   rw [Fintype.prod_sum_type]
   simp only [Finset.univ_unique, PUnit.default_eq_unit, Nat.succ_eq_add_one, Finset.prod_singleton,
@@ -267,10 +267,9 @@ lemma insert_fin_eq_self (φ : 𝓕.States) {φs : List 𝓕.States}
     rfl
 
 lemma insertList_uncontractedList_none_map (φ : 𝓕.States) {φs : List 𝓕.States}
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) :
-    List.map (List.insertIdx (↑i) φ φs).get (insertList φ c i none).uncontractedList =
-    List.insertIdx (c.uncontractedListOrderPos i) φ (List.map φs.get c.uncontractedList) := by
-  simp only [Nat.succ_eq_add_one, insertList]
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
+    [φsΛ.insertList φ i none]ᵘᶜ = List.insertIdx (φsΛ.uncontractedListOrderPos i) φ [φsΛ]ᵘᶜ := by
+  simp only [Nat.succ_eq_add_one, insertList, uncontractedListGet]
   rw [congr_uncontractedList]
   erw [uncontractedList_extractEquiv_symm_none]
   rw [orderedInsert_succAboveEmb_uncontractedList_eq_insertIdx]
@@ -284,8 +283,8 @@ lemma insertList_uncontractedList_none_map (φ : 𝓕.States) {φs : List 𝓕.S
 
 lemma insertLift_sum (φ : 𝓕.States) {φs : List 𝓕.States}
     (i : Fin φs.length.succ) [AddCommMonoid M] (f : WickContraction (φs.insertIdx i φ).length → M) :
-    ∑ c, f c = ∑ (c : WickContraction φs.length), ∑ (k : Option (c.uncontracted)),
-      f (insertList φ c i k) := by
+    ∑ c, f c = ∑ (φsΛ : WickContraction φs.length), ∑ (k : Option φsΛ.uncontracted),
+      f (φsΛ.insertList φ i k) := by
   rw [sum_extractEquiv_congr (finCongr (insertIdx_length_fin φ φs i).symm i) f
     (insertIdx_length_fin φ φs i)]
   rfl
diff --git a/HepLean/PerturbationTheory/WickContraction/Sign.lean b/HepLean/PerturbationTheory/WickContraction/Sign.lean
index 669c16c..0bcd9bd 100644
--- a/HepLean/PerturbationTheory/WickContraction/Sign.lean
+++ b/HepLean/PerturbationTheory/WickContraction/Sign.lean
@@ -28,15 +28,15 @@ def signFinset (c : WickContraction n) (i1 i2 : Fin n) : Finset (Fin n) :=
   (c.getDual? i = none ∨ ∀ (h : (c.getDual? i).isSome), i1 < (c.getDual? i).get h))
 
 lemma signFinset_insertList_none (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
+    (φsΛ : WickContraction φs.length)
     (i : Fin φs.length.succ) (i1 i2 : Fin φs.length) :
-      (c.insertList φ i none).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
+      (φsΛ.insertList φ i none).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
       (i.succAbove i1)) (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove i2)) =
     if i.succAbove i1 < i ∧ i < i.succAbove i2 then
       Insert.insert (finCongr (insertIdx_length_fin φ φs i).symm i)
-      (insertListLiftFinset φ i (c.signFinset i1 i2))
+      (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))
     else
-      (insertListLiftFinset φ i (c.signFinset i1 i2)) := by
+      (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)) := by
   ext k
   rcases insert_fin_eq_self φ i k with hk | hk
   · subst hk
@@ -54,10 +54,10 @@ lemma signFinset_insertList_none (φ : 𝓕.States) (φs : List 𝓕.States)
     have h1 : Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove k) ∈
       (if i.succAbove i1 < i ∧ i < i.succAbove i2 then
         Insert.insert ((finCongr (insertIdx_length_fin φ φs i).symm) i)
-        (insertListLiftFinset φ i (c.signFinset i1 i2))
-      else insertListLiftFinset φ i (c.signFinset i1 i2)) ↔
+        (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))
+      else insertListLiftFinset φ i (φsΛ.signFinset i1 i2)) ↔
       Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove k) ∈
-        insertListLiftFinset φ i (c.signFinset i1 i2) := by
+        insertListLiftFinset φ i (φsΛ.signFinset i1 i2) := by
       split
       · simp only [Nat.succ_eq_add_one, finCongr_apply, Finset.mem_insert, Fin.ext_iff,
         Fin.coe_cast, or_iff_right_iff_imp]
@@ -142,13 +142,13 @@ lemma stat_ofFinset_of_insertListLiftFinset (φ : 𝓕.States) (φs : List 𝓕.
   rw [(List.toFinset_sort (· ≤ ·) h2).mpr h1]
 
 lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.States)
-    (a : Finset (Fin φs.length)) (c : WickContraction φs.length) (hg : GradingCompliant φs c)
-    (hnon : ∀ i, c.getDual? i = none → i ∉ a)
-    (hsom : ∀ i, (h : (c.getDual? i).isSome) → i ∈ a → (c.getDual? i).get h ∈ a) :
+    (a : Finset (Fin φs.length)) (φsΛ : WickContraction φs.length) (hg : GradingCompliant φs φsΛ)
+    (hnon : ∀ i, φsΛ.getDual? i = none → i ∉ a)
+    (hsom : ∀ i, (h : (φsΛ.getDual? i).isSome) → i ∈ a → (φsΛ.getDual? i).get h ∈ a) :
     (𝓕 |>ₛ ⟨φs.get, a⟩) = 1 := by
   rw [ofFinset_eq_prod]
-  let e2 : Fin φs.length ≃ {x // (c.getDual? x).isSome} ⊕ {x // ¬ (c.getDual? x).isSome} := by
-    exact (Equiv.sumCompl fun a => (c.getDual? a).isSome = true).symm
+  let e2 : Fin φs.length ≃ {x // (φsΛ.getDual? x).isSome} ⊕ {x // ¬ (φsΛ.getDual? x).isSome} := by
+    exact (Equiv.sumCompl fun a => (φsΛ.getDual? a).isSome = true).symm
   rw [← e2.symm.prod_comp]
   simp only [Fin.getElem_fin, Fintype.prod_sum_type, instCommGroup]
   conv_lhs =>
@@ -156,7 +156,7 @@ lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.States)
     simp only [Equiv.symm_symm, Equiv.sumCompl_apply_inl, Equiv.sumCompl_apply_inr, e2]
     rw [if_neg (hnon x.1 (by simpa using x.2))]
   simp only [Equiv.symm_symm, Equiv.sumCompl_apply_inl, Finset.prod_const_one, mul_one, e2]
-  rw [← c.sigmaContractedEquiv.prod_comp]
+  rw [← φsΛ.sigmaContractedEquiv.prod_comp]
   erw [Finset.prod_sigma]
   apply Fintype.prod_eq_one _
   intro x
@@ -167,43 +167,43 @@ lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.States)
     erw [hg x]
     simp only [Fin.getElem_fin, mul_self]
     rename_i h1 h2
-    have hsom' := hsom (c.sndFieldOfContract x) (by simp) h1
+    have hsom' := hsom (φsΛ.sndFieldOfContract x) (by simp) h1
     simp only [sndFieldOfContract_getDual?, Option.get_some] at hsom'
     exact False.elim (h2 hsom')
   · split
     rename_i h1 h2
-    have hsom' := hsom (c.fstFieldOfContract x) (by simp) h2
+    have hsom' := hsom (φsΛ.fstFieldOfContract x) (by simp) h2
     simp only [fstFieldOfContract_getDual?, Option.get_some] at hsom'
     exact False.elim (h1 hsom')
     rfl
 
 lemma signFinset_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (i1 i2 : Fin φs.length)
-    (j : c.uncontracted) :
-    (c.insertList φ i (some j)).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (i1 i2 : Fin φs.length)
+    (j : φsΛ.uncontracted) :
+    (φsΛ.insertList φ i (some j)).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
     (i.succAbove i1)) (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove i2)) =
     if i.succAbove i1 < i ∧ i < i.succAbove i2 ∧ (i1 < j) then
       Insert.insert (finCongr (insertIdx_length_fin φ φs i).symm i)
-      (insertListLiftFinset φ i (c.signFinset i1 i2))
+      (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))
     else
       if i1 < j ∧ j < i2 ∧ ¬ i.succAbove i1 < i then
-        (insertListLiftFinset φ i (c.signFinset i1 i2)).erase
+        (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)).erase
         (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
       else
-        (insertListLiftFinset φ i (c.signFinset i1 i2)) := by
+        (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)) := by
   ext k
   rcases insert_fin_eq_self φ i k with hk | hk
   · subst hk
     have h1 : Fin.cast (insertIdx_length_fin φ φs i).symm i ∈
       (if i.succAbove i1 < i ∧ i < i.succAbove i2 ∧ (i1 < j) then
       Insert.insert (finCongr (insertIdx_length_fin φ φs i).symm i)
-      (insertListLiftFinset φ i (c.signFinset i1 i2))
+      (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))
       else
         if i1 < j ∧ j < i2 ∧ ¬ i.succAbove i1 < i then
-          (insertListLiftFinset φ i (c.signFinset i1 i2)).erase
+          (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)).erase
           (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
         else
-          (insertListLiftFinset φ i (c.signFinset i1 i2))) ↔
+          (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))) ↔
           i.succAbove i1 < i ∧ i < i.succAbove i2 ∧ (i1 < j) := by
         split
         simp_all only [Nat.succ_eq_add_one, finCongr_apply, Finset.mem_insert,
@@ -270,15 +270,15 @@ lemma signFinset_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
     · have h1 : Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove k) ∈
         (if i.succAbove i1 < i ∧ i < i.succAbove i2 ∧ (i1 < j) then
         Insert.insert (finCongr (insertIdx_length_fin φ φs i).symm i)
-        (insertListLiftFinset φ i (c.signFinset i1 i2))
+        (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))
         else
         if i1 < j ∧ j < i2 ∧ ¬ i.succAbove i1 < i then
-          (insertListLiftFinset φ i (c.signFinset i1 i2)).erase
+          (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)).erase
           (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
         else
-          (insertListLiftFinset φ i (c.signFinset i1 i2))) ↔
+          (insertListLiftFinset φ i (φsΛ.signFinset i1 i2))) ↔
           Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove k) ∈
-          (insertListLiftFinset φ i (c.signFinset i1 i2)) := by
+          (insertListLiftFinset φ i (φsΛ.signFinset i1 i2)) := by
         split
         · simp only [Nat.succ_eq_add_one, finCongr_apply, Finset.mem_insert, or_iff_right_iff_imp]
           intro h
@@ -320,9 +320,9 @@ lemma signFinset_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
   of `c` next to each other.
   It is important to note that this sign does not depend on any ordering
   placed on `φs` other then the order of the list itself. -/
-def sign (φs : List 𝓕.States) (c : WickContraction φs.length) : ℂ :=
-  ∏ (a : c.1), 𝓢(𝓕 |>ₛ φs[c.sndFieldOfContract a],
-    𝓕 |>ₛ ⟨φs.get, c.signFinset (c.fstFieldOfContract a) (c.sndFieldOfContract a)⟩)
+def sign (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) : ℂ :=
+  ∏ (a : φsΛ.1), 𝓢(𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a],
+    𝓕 |>ₛ ⟨φs.get, φsΛ.signFinset (φsΛ.fstFieldOfContract a) (φsΛ.sndFieldOfContract a)⟩)
 
 /-!
 
@@ -332,16 +332,16 @@ def sign (φs : List 𝓕.States) (c : WickContraction φs.length) : ℂ :=
 /-- Given a Wick contraction `c` associated with a list of states `φs`
   and an `i : Fin φs.length.succ`, the change in sign of the contraction associated with
   inserting `φ` into `φs` at position `i` without contracting it. -/
-def signInsertNone (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
+def signInsertNone (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
     (i : Fin φs.length.succ) : ℂ :=
-  ∏ (a : c.1),
-    if i.succAbove (c.fstFieldOfContract a) < i ∧ i < i.succAbove (c.sndFieldOfContract a) then
-      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+  ∏ (a : φsΛ.1),
+    if i.succAbove (φsΛ.fstFieldOfContract a) < i ∧ i < i.succAbove (φsΛ.sndFieldOfContract a) then
+      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else 1
 
-lemma sign_insert_none (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
+lemma sign_insert_none (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
     (i : Fin φs.length.succ) :
-    (c.insertList φ i none).sign = (c.signInsertNone φ φs i) * c.sign := by
+    (φsΛ.insertList φ i none).sign = (φsΛ.signInsertNone φ φs i) * φsΛ.sign := by
   rw [sign]
   rw [signInsertNone, sign, ← Finset.prod_mul_distrib]
   rw [insertList_none_prod_contractions]
@@ -361,11 +361,11 @@ lemma sign_insert_none (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickCont
   · rw [stat_ofFinset_of_insertListLiftFinset]
 
 lemma signInsertNone_eq_mul_fst_snd (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) :
-  c.signInsertNone φ φs i = ∏ (a : c.1),
-    (if i.succAbove (c.fstFieldOfContract a) < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
+  φsΛ.signInsertNone φ φs i = ∏ (a : φsΛ.1),
+    (if i.succAbove (φsΛ.fstFieldOfContract a) < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else 1) *
-    (if i.succAbove (c.sndFieldOfContract a) < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+    (if i.succAbove (φsΛ.sndFieldOfContract a) < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else 1) := by
   rw [signInsertNone]
   congr
@@ -382,20 +382,20 @@ lemma signInsertNone_eq_mul_fst_snd (φ : 𝓕.States) (φs : List 𝓕.States)
     · simp_all only [forall_const, instCommGroup.eq_1, Fin.getElem_fin, mul_ite,
       exchangeSign_mul_self, mul_one]
       rw [if_pos]
-      have h1 :i.succAbove (c.sndFieldOfContract a) ≠ i :=
-        Fin.succAbove_ne i (c.sndFieldOfContract a)
+      have h1 :i.succAbove (φsΛ.sndFieldOfContract a) ≠ i :=
+        Fin.succAbove_ne i (φsΛ.sndFieldOfContract a)
       omega
     · simp only [not_lt] at h1
       rw [if_neg]
       simp only [mul_one]
-      have hn := fstFieldOfContract_lt_sndFieldOfContract c a
-      have hx : i.succAbove (c.fstFieldOfContract a) < i.succAbove (c.sndFieldOfContract a) := by
+      have hn := fstFieldOfContract_lt_sndFieldOfContract φsΛ a
+      have hx : i.succAbove (φsΛ.fstFieldOfContract a) < i.succAbove (φsΛ.sndFieldOfContract a) := by
         exact Fin.succAbove_lt_succAbove_iff.mpr hn
       omega
 
 lemma signInsertNone_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs c) :
-    c.signInsertNone φ φs i = ∏ (a : c.1), ∏ (x : a),
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertNone φ φs i = ∏ (a : φsΛ.1), ∏ (x : a),
       (if i.succAbove x < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.1]) else 1) := by
   rw [signInsertNone_eq_mul_fst_snd]
   congr
@@ -409,18 +409,18 @@ lemma signInsertNone_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
   rfl
 
 lemma signInsertNone_eq_prod_getDual?_Some (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs c) :
-    c.signInsertNone φ φs i = ∏ (x : Fin φs.length),
-      if (c.getDual? x).isSome then
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertNone φ φs i = ∏ (x : Fin φs.length),
+      if (φsΛ.getDual? x).isSome then
         (if i.succAbove x < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.1]) else 1)
       else 1 := by
   rw [signInsertNone_eq_prod_prod]
-  trans ∏ (x : (a : c.1) × a), (if i.succAbove x.2 < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.2.1]) else 1)
+  trans ∏ (x : (a : φsΛ.1) × a), (if i.succAbove x.2 < i then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.2.1]) else 1)
   · rw [Finset.prod_sigma']
     rfl
-  rw [← c.sigmaContractedEquiv.symm.prod_comp]
-  let e2 : Fin φs.length ≃ {x // (c.getDual? x).isSome} ⊕ {x // ¬ (c.getDual? x).isSome} := by
-    exact (Equiv.sumCompl fun a => (c.getDual? a).isSome = true).symm
+  rw [← φsΛ.sigmaContractedEquiv.symm.prod_comp]
+  let e2 : Fin φs.length ≃ {x // (φsΛ.getDual? x).isSome} ⊕ {x // ¬ (φsΛ.getDual? x).isSome} := by
+    exact (Equiv.sumCompl fun a => (φsΛ.getDual? a).isSome = true).symm
   rw [← e2.symm.prod_comp]
   simp only [instCommGroup.eq_1, Fin.getElem_fin, Fintype.prod_sum_type]
   conv_rhs =>
@@ -436,9 +436,9 @@ lemma signInsertNone_eq_prod_getDual?_Some (φ : 𝓕.States) (φs : List 𝓕.S
   exact hG
 
 lemma signInsertNone_eq_filter_map (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs c) :
-    c.signInsertNone φ φs i =
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ((List.filter (fun x => (c.getDual? x).isSome ∧ i.succAbove x < i)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertNone φ φs i =
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ((List.filter (fun x => (φsΛ.getDual? x).isSome ∧ i.succAbove x < i)
     (List.finRange φs.length)).map φs.get)) := by
   rw [signInsertNone_eq_prod_getDual?_Some]
   rw [FieldStatistic.ofList_map_eq_finset_prod]
@@ -460,10 +460,10 @@ lemma signInsertNone_eq_filter_map (φ : 𝓕.States) (φs : List 𝓕.States)
   · exact hG
 
 lemma signInsertNone_eq_filterset (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (hG : GradingCompliant φs c) :
-    c.signInsertNone φ φs i = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter
-    (fun x => (c.getDual? x).isSome ∧ i.succAbove x < i)⟩) := by
+    (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (hG : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertNone φ φs i = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter
+    (fun x => (φsΛ.getDual? x).isSome ∧ i.succAbove x < i)⟩) := by
   rw [ofFinset_eq_prod, signInsertNone_eq_prod_getDual?_Some, map_prod]
   congr
   funext a
@@ -489,16 +489,16 @@ lemma signInsertNone_eq_filterset (φ : 𝓕.States) (φs : List 𝓕.States)
   inserting `φ` into `φs` at position `i` and contracting it with `j : c.uncontracted`
   coming from contractions other then the `i` and `j` contraction but which
   are effected by this new contraction. -/
-def signInsertSomeProd (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) : ℂ :=
-  ∏ (a : c.1),
-    if i.succAbove (c.fstFieldOfContract a) < i ∧ i < i.succAbove (c.sndFieldOfContract a) ∧
-      ((c.fstFieldOfContract a) < j) then
-      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+def signInsertSomeProd (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) : ℂ :=
+  ∏ (a : φsΛ.1),
+    if i.succAbove (φsΛ.fstFieldOfContract a) < i ∧ i < i.succAbove (φsΛ.sndFieldOfContract a) ∧
+      ((φsΛ.fstFieldOfContract a) < j) then
+      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else
-    if (c.fstFieldOfContract a) < j ∧ j < (c.sndFieldOfContract a) ∧
-        ¬ i.succAbove (c.fstFieldOfContract a) < i then
-      𝓢(𝓕 |>ₛ φs[j.1], 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+    if (φsΛ.fstFieldOfContract a) < j ∧ j < (φsΛ.sndFieldOfContract a) ∧
+        ¬ i.succAbove (φsΛ.fstFieldOfContract a) < i then
+      𝓢(𝓕 |>ₛ φs[j.1], 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else
       1
 
@@ -506,26 +506,26 @@ def signInsertSomeProd (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickCont
   and an `i : Fin φs.length.succ`, the change in sign of the contraction associated with
   inserting `φ` into `φs` at position `i` and contracting it with `j : c.uncontracted`
   coming from putting `i` next to `j`. -/
-def signInsertSomeCoef (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) : ℂ :=
-  let a : (c.insertList φ i (some j)).1 :=
+def signInsertSomeCoef (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) : ℂ :=
+  let a : (φsΛ.insertList φ i (some j)).1 :=
     congrLift (insertIdx_length_fin φ φs i).symm
     ⟨{i, i.succAbove j}, by simp [insert]⟩;
-  𝓢(𝓕 |>ₛ (φs.insertIdx i φ)[(c.insertList φ i (some j)).sndFieldOfContract a],
+  𝓢(𝓕 |>ₛ (φs.insertIdx i φ)[(φsΛ.insertList φ i (some j)).sndFieldOfContract a],
     𝓕 |>ₛ ⟨(φs.insertIdx i φ).get, signFinset
-    (c.insertList φ i (some j)) ((c.insertList φ i (some j)).fstFieldOfContract a)
-    ((c.insertList φ i (some j)).sndFieldOfContract a)⟩)
+    (φsΛ.insertList φ i (some j)) ((φsΛ.insertList φ i (some j)).fstFieldOfContract a)
+    ((φsΛ.insertList φ i (some j)).sndFieldOfContract a)⟩)
 
 /-- Given a Wick contraction `c` associated with a list of states `φs`
   and an `i : Fin φs.length.succ`, the change in sign of the contraction associated with
   inserting `φ` into `φs` at position `i` and contracting it with `j : c.uncontracted`. -/
-def signInsertSome (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) : ℂ :=
-  signInsertSomeCoef φ φs c i j * signInsertSomeProd φ φs c i j
+def signInsertSome (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) : ℂ :=
+  signInsertSomeCoef φ φs φsΛ i j * signInsertSomeProd φ φs φsΛ i j
 
-lemma sign_insert_some (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) :
-    (c.insertList φ i (some j)).sign = (c.signInsertSome φ φs i j) * c.sign := by
+lemma sign_insert_some (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    (φsΛ.insertList φ i (some j)).sign = (φsΛ.signInsertSome φ φs i j) * φsΛ.sign := by
   rw [sign]
   rw [signInsertSome, signInsertSomeProd, sign, mul_assoc, ← Finset.prod_mul_distrib]
   rw [insertList_some_prod_contractions]
@@ -565,15 +565,15 @@ lemma sign_insert_some (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickCont
       simp_all
 
 lemma signInsertSomeProd_eq_one_if (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted)
     (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) :
-  c.signInsertSomeProd φ φs i j =
-  ∏ (a : c.1),
-    if (c.fstFieldOfContract a) < j
-      ∧ (i.succAbove (c.fstFieldOfContract a) < i ∧ i < i.succAbove (c.sndFieldOfContract a)
-      ∨ j < (c.sndFieldOfContract a) ∧ ¬ i.succAbove (c.fstFieldOfContract a) < i)
+  φsΛ.signInsertSomeProd φ φs i j =
+  ∏ (a : φsΛ.1),
+    if (φsΛ.fstFieldOfContract a) < j
+      ∧ (i.succAbove (φsΛ.fstFieldOfContract a) < i ∧ i < i.succAbove (φsΛ.sndFieldOfContract a)
+      ∨ j < (φsΛ.sndFieldOfContract a) ∧ ¬ i.succAbove (φsΛ.fstFieldOfContract a) < i)
     then
-      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[c.sndFieldOfContract a])
+      𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
     else
       1 := by
   rw [signInsertSomeProd]
@@ -598,13 +598,14 @@ lemma signInsertSomeProd_eq_one_if (φ : 𝓕.States) (φs : List 𝓕.States)
       omega
 
 lemma signInsertSomeProd_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
-    (hg : GradingCompliant φs c) :
-  c.signInsertSomeProd φ φs i j =
-  ∏ (a : c.1), ∏ (x : a.1), if x.1 < j
-      ∧ (i.succAbove x.1 < i ∧ i < i.succAbove ((c.getDual? x.1).get (getDual?_isSome_of_mem c a x))
-      ∨ j < ((c.getDual? x.1).get (getDual?_isSome_of_mem c a x)) ∧ ¬ i.succAbove x < i)
+    (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
+    (hg : GradingCompliant φs φsΛ) :
+  φsΛ.signInsertSomeProd φ φs i j =
+  ∏ (a : φsΛ.1), ∏ (x : a.1), if x.1 < j
+      ∧ (i.succAbove x.1 < i ∧
+      i < i.succAbove ((φsΛ.getDual? x.1).get (getDual?_isSome_of_mem φsΛ a x))
+      ∨ j < ((φsΛ.getDual? x.1).get (getDual?_isSome_of_mem φsΛ a x)) ∧ ¬ i.succAbove x < i)
     then
       𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.1])
     else
@@ -622,32 +623,32 @@ lemma signInsertSomeProd_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States
   · simp only [Nat.succ_eq_add_one, sndFieldOfContract_getDual?, Option.get_some, not_lt, not_and,
     not_or, not_le]
     intro h1
-    have ha := fstFieldOfContract_lt_sndFieldOfContract c a
+    have ha := fstFieldOfContract_lt_sndFieldOfContract φsΛ a
     apply And.intro
     · intro hi
-      have hx : i.succAbove (c.fstFieldOfContract a) < i.succAbove (c.sndFieldOfContract a) := by
+      have hx : i.succAbove (φsΛ.fstFieldOfContract a) < i.succAbove (φsΛ.sndFieldOfContract a) := by
         exact Fin.succAbove_lt_succAbove_iff.mpr ha
       omega
     · omega
   simp [hφj]
 
 lemma signInsertSomeProd_eq_prod_fin (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
-    (hg : GradingCompliant φs c) :
-  c.signInsertSomeProd φ φs i j =
+    (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
+    (hg : GradingCompliant φs φsΛ) :
+  φsΛ.signInsertSomeProd φ φs i j =
     ∏ (x : Fin φs.length),
-      if h : (c.getDual? x).isSome then
-          if x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((c.getDual? x).get h)
-            ∨ j < ((c.getDual? x).get h) ∧ ¬ i.succAbove x < i)
+      if h : (φsΛ.getDual? x).isSome then
+          if x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((φsΛ.getDual? x).get h)
+            ∨ j < ((φsΛ.getDual? x).get h) ∧ ¬ i.succAbove x < i)
           then 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs[x.1])
           else 1
       else 1 := by
   rw [signInsertSomeProd_eq_prod_prod]
   rw [Finset.prod_sigma']
-  erw [← c.sigmaContractedEquiv.symm.prod_comp]
-  let e2 : Fin φs.length ≃ {x // (c.getDual? x).isSome} ⊕ {x // ¬ (c.getDual? x).isSome} := by
-    exact (Equiv.sumCompl fun a => (c.getDual? a).isSome = true).symm
+  erw [← φsΛ.sigmaContractedEquiv.symm.prod_comp]
+  let e2 : Fin φs.length ≃ {x // (φsΛ.getDual? x).isSome} ⊕ {x // ¬ (φsΛ.getDual? x).isSome} := by
+    exact (Equiv.sumCompl fun a => (φsΛ.getDual? a).isSome = true).symm
   rw [← e2.symm.prod_comp]
   simp only [instCommGroup.eq_1, Fin.getElem_fin, Fintype.prod_sum_type]
   conv_rhs =>
@@ -665,13 +666,13 @@ lemma signInsertSomeProd_eq_prod_fin (φ : 𝓕.States) (φs : List 𝓕.States)
   exact hg
 
 lemma signInsertSomeProd_eq_list (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
-    (hg : GradingCompliant φs c) :
-    c.signInsertSomeProd φ φs i j =
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (List.filter (fun x => (c.getDual? x).isSome ∧ ∀ (h : (c.getDual? x).isSome),
-      x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((c.getDual? x).get h)
-      ∨ j < ((c.getDual? x).get h) ∧ ¬ i.succAbove x < i))
+    (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
+    (hg : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertSomeProd φ φs i j =
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (List.filter (fun x => (φsΛ.getDual? x).isSome ∧ ∀ (h : (φsΛ.getDual? x).isSome),
+      x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((φsΛ.getDual? x).get h)
+      ∨ j < ((φsΛ.getDual? x).get h) ∧ ¬ i.succAbove x < i))
     (List.finRange φs.length)).map φs.get) := by
   rw [signInsertSomeProd_eq_prod_fin]
   rw [FieldStatistic.ofList_map_eq_finset_prod]
@@ -698,14 +699,14 @@ lemma signInsertSomeProd_eq_list (φ : 𝓕.States) (φs : List 𝓕.States)
   exact hg
 
 lemma signInsertSomeProd_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
-    (hg : GradingCompliant φs c) :
-    c.signInsertSomeProd φ φs i j =
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => (c.getDual? x).isSome ∧
-      ∀ (h : (c.getDual? x).isSome),
-      x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((c.getDual? x).get h)
-      ∨ j < ((c.getDual? x).get h) ∧ ¬ i.succAbove x < i)))⟩) := by
+    (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
+    (hg : GradingCompliant φs φsΛ) :
+    φsΛ.signInsertSomeProd φ φs i j =
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => (φsΛ.getDual? x).isSome ∧
+      ∀ (h : (φsΛ.getDual? x).isSome),
+      x < j ∧ (i.succAbove x < i ∧ i < i.succAbove ((φsΛ.getDual? x).get h)
+      ∨ j < ((φsΛ.getDual? x).get h) ∧ ¬ i.succAbove x < i)))⟩) := by
   rw [signInsertSomeProd_eq_prod_fin]
   rw [ofFinset_eq_prod]
   rw [map_prod]
@@ -725,16 +726,16 @@ lemma signInsertSomeProd_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
   simp only [hφj, Fin.getElem_fin]
   exact hg
 
-lemma signInsertSomeCoef_if (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) :
-    c.signInsertSomeCoef φ φs i j =
+lemma signInsertSomeCoef_if (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) :
+    φsΛ.signInsertSomeCoef φ φs i j =
     if i < i.succAbove j then
       𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
-      (signFinset (c.insertList φ i (some j)) (finCongr (insertIdx_length_fin φ φs i).symm i)
+      (signFinset (φsΛ.insertList φ i (some j)) (finCongr (insertIdx_length_fin φ φs i).symm i)
       (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j)))⟩)
     else
       𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
-      signFinset (c.insertList φ i (some j))
+      signFinset (φsΛ.insertList φ i (some j))
       (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
       (finCongr (insertIdx_length_fin φ φs i).symm i)⟩) := by
   simp only [signInsertSomeCoef, instCommGroup.eq_1, Nat.succ_eq_add_one,
@@ -745,14 +746,14 @@ lemma signInsertSomeCoef_if (φ : 𝓕.States) (φs : List 𝓕.States) (c : Wic
   · simp [hφj]
 
 lemma stat_signFinset_insert_some_self_fst
-    (φ : 𝓕.States) (φs : List 𝓕.States) (c : WickContraction φs.length)
-    (i : Fin φs.length.succ) (j : c.uncontracted) :
+    (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
+    (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
   (𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
-    (signFinset (c.insertList φ i (some j)) (finCongr (insertIdx_length_fin φ φs i).symm i)
+    (signFinset (φsΛ.insertList φ i (some j)) (finCongr (insertIdx_length_fin φ φs i).symm i)
       (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j)))⟩) =
   𝓕 |>ₛ ⟨φs.get,
-    (Finset.univ.filter (fun x => i < i.succAbove x ∧ x < j ∧ ((c.getDual? x = none) ∨
-      ∀ (h : (c.getDual? x).isSome), i < i.succAbove ((c.getDual? x).get h))))⟩ := by
+    (Finset.univ.filter (fun x => i < i.succAbove x ∧ x < j ∧ ((φsΛ.getDual? x = none) ∨
+      ∀ (h : (φsΛ.getDual? x).isSome), i < i.succAbove ((φsΛ.getDual? x).get h))))⟩ := by
   rw [get_eq_insertIdx_succAbove φ _ i]
   rw [ofFinset_finset_map]
   swap
@@ -822,14 +823,14 @@ lemma stat_signFinset_insert_some_self_fst
             simpa [Option.get_map] using hy2
 
 lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
     (𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
-    (signFinset (c.insertList φ i (some j))
+    (signFinset (φsΛ.insertList φ i (some j))
       (finCongr (insertIdx_length_fin φ φs i).symm (i.succAbove j))
       (finCongr (insertIdx_length_fin φ φs i).symm i))⟩) =
     𝓕 |>ₛ ⟨φs.get,
-    (Finset.univ.filter (fun x => j < x ∧ i.succAbove x < i ∧ ((c.getDual? x = none) ∨
-      ∀ (h : (c.getDual? x).isSome), j < ((c.getDual? x).get h))))⟩ := by
+    (Finset.univ.filter (fun x => j < x ∧ i.succAbove x < i ∧ ((φsΛ.getDual? x = none) ∨
+      ∀ (h : (φsΛ.getDual? x).isSome), j < ((φsΛ.getDual? x).get h))))⟩ := by
   rw [get_eq_insertIdx_succAbove φ _ i, ofFinset_finset_map]
   swap
   refine
@@ -902,25 +903,25 @@ lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.States) (φs : List 𝓕.S
             exact Fin.succAbove_lt_succAbove_iff.mpr hy2
 
 lemma signInsertSomeCoef_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted)
-    (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) : c.signInsertSomeCoef φ φs i j =
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted)
+    (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) : φsΛ.signInsertSomeCoef φ φs i j =
     if i < i.succAbove j then
       𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get,
-      (Finset.univ.filter (fun x => i < i.succAbove x ∧ x < j ∧ ((c.getDual? x = none) ∨
-        ∀ (h : (c.getDual? x).isSome), i < i.succAbove ((c.getDual? x).get h))))⟩)
+      (Finset.univ.filter (fun x => i < i.succAbove x ∧ x < j ∧ ((φsΛ.getDual? x = none) ∨
+        ∀ (h : (φsΛ.getDual? x).isSome), i < i.succAbove ((φsΛ.getDual? x).get h))))⟩)
     else
       𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get,
-        (Finset.univ.filter (fun x => j < x ∧ i.succAbove x < i ∧ ((c.getDual? x = none) ∨
-        ∀ (h : (c.getDual? x).isSome), j < ((c.getDual? x).get h))))⟩) := by
+        (Finset.univ.filter (fun x => j < x ∧ i.succAbove x < i ∧ ((φsΛ.getDual? x = none) ∨
+        ∀ (h : (φsΛ.getDual? x).isSome), j < ((φsΛ.getDual? x).get h))))⟩) := by
   rw [signInsertSomeCoef_if, stat_signFinset_insert_some_self_snd,
     stat_signFinset_insert_some_self_fst]
   simp [hφj]
 
 lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (k : c.uncontracted)
-    (hk : i.succAbove k < i) (hg : GradingCompliant φs c ∧ (𝓕 |>ₛ φ) = 𝓕 |>ₛ φs[k.1]) :
-    signInsertSome φ φs c i k *
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, c.uncontracted.filter (fun x => x ≤ ↑k)⟩)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
+    (hk : i.succAbove k < i) (hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = 𝓕 |>ₛ φs[k.1]) :
+    signInsertSome φ φs φsΛ i k *
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => x ≤ ↑k)⟩)
     = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => i.succAbove x < i)⟩) := by
   rw [signInsertSome, signInsertSomeProd_eq_finset (hφj := hg.2) (hg := hg.1),
     signInsertSomeCoef_eq_finset (hφj := hg.2), if_neg (by omega), ← map_mul, ← map_mul]
@@ -965,19 +966,19 @@ 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 := Option.isSome_iff_ne_none.mp hj
+    have hn : ¬ φsΛ.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 := Fin.succAbove_ne i _
+    have hijsucc' : i.succAbove ((φsΛ.getDual? j).get hj) ≠ i := Fin.succAbove_ne i _
     have hkneqj : ↑k ≠ j := by
       by_contra hkj
       have hk := k.prop
       simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and] at hk
       simp_all
-    have hkneqgetdual : k.1 ≠ (c.getDual? j).get hj := by
+    have hkneqgetdual : k.1 ≠ (φsΛ.getDual? j).get hj := by
       by_contra hkj
       have hk := k.prop
       simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and] at hk
@@ -990,14 +991,14 @@ lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List
         · simp [h1]
         · simp [h1]
       simp only [hir, true_and, or_true, forall_const] at h1 h2
-      have hnkdual : ¬ ↑k < (c.getDual? j).get hj := by
+      have hnkdual : ¬ ↑k < (φsΛ.getDual? j).get hj := by
         by_contra hn
         have h2 := h2 hn
         apply Fin.ne_succAbove i j
         omega
       simp only [hnkdual, IsEmpty.forall_iff, false_and, false_or, and_imp] at h2 ⊢
-      have hnkdual : (c.getDual? j).get hj < ↑k := by omega
-      have hi : i.succAbove ((c.getDual? j).get hj) < i.succAbove k := by
+      have hnkdual : (φsΛ.getDual? j).get hj < ↑k := by omega
+      have hi : i.succAbove ((φsΛ.getDual? j).get hj) < i.succAbove k := by
         rw [@Fin.succAbove_lt_succAbove_iff]
         omega
       omega
@@ -1020,10 +1021,10 @@ lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List
         omega
 
 lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (k : c.uncontracted)
-    (hk : ¬ i.succAbove k < i) (hg : GradingCompliant φs c ∧ (𝓕 |>ₛ φ) = 𝓕 |>ₛ φs[k.1]) :
-    signInsertSome φ φs c i k *
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, c.uncontracted.filter (fun x => x < ↑k)⟩)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
+    (hk : ¬ i.succAbove k < i) (hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = 𝓕 |>ₛ φs[k.1]) :
+    signInsertSome φ φs φsΛ i k *
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => x < ↑k)⟩)
     = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => i.succAbove x < i)⟩) := by
   have hik : i.succAbove ↑k ≠ i := Fin.succAbove_ne i ↑k
   rw [signInsertSome, signInsertSomeProd_eq_finset (hφj := hg.2) (hg := hg.1),
@@ -1055,14 +1056,14 @@ 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 := Option.isSome_iff_ne_none.mp hj
+    have hn : ¬ φsΛ.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
       simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and] at hk
       simp_all
-    have hkneqgetdual : k.1 ≠ (c.getDual? j).get hj := by
+    have hkneqgetdual : k.1 ≠ (φsΛ.getDual? j).get hj := by
       by_contra hkj
       have hk := k.prop
       simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and] at hk
@@ -1100,7 +1101,7 @@ lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : L
           · apply Or.inl
             omega
           · apply Or.inl
-            have hi : i.succAbove k.1 < i.succAbove ((c.getDual? j).get hj) := by
+            have hi : i.succAbove k.1 < i.succAbove ((φsΛ.getDual? j).get hj) := by
               rw [Fin.succAbove_lt_succAbove_iff]
               omega
             apply And.intro
@@ -1117,6 +1118,6 @@ lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : L
         have hijn' : ¬ i ≤ i.succAbove j := by omega
         simp only [hijn, true_and, hijn', and_false, or_false, or_true, imp_false, not_lt,
           forall_const]
-        exact fun h => lt_of_le_of_ne h (Fin.succAbove_ne i ((c.getDual? j).get hj))
+        exact fun h => lt_of_le_of_ne h (Fin.succAbove_ne i ((φsΛ.getDual? j).get hj))
 
 end WickContraction
diff --git a/HepLean/PerturbationTheory/WickContraction/TimeContract.lean b/HepLean/PerturbationTheory/WickContraction/TimeContract.lean
index e8c2bd7..924e965 100644
--- a/HepLean/PerturbationTheory/WickContraction/TimeContract.lean
+++ b/HepLean/PerturbationTheory/WickContraction/TimeContract.lean
@@ -22,26 +22,27 @@ open HepLean.List
   product of all time-contractions of pairs of contracted elements in `φs`,
   as a member of the center of `𝓞.A`. -/
 noncomputable def timeContract (𝓞 : 𝓕.ProtoOperatorAlgebra) {φs : List 𝓕.States}
-    (c : WickContraction φs.length) :
+    (φsΛ : WickContraction φs.length) :
     Subalgebra.center ℂ 𝓞.A :=
-  ∏ (a : c.1), ⟨𝓞.timeContract (φs.get (c.fstFieldOfContract a)) (φs.get (c.sndFieldOfContract a)),
+  ∏ (a : φsΛ.1), ⟨𝓞.timeContract
+    (φs.get (φsΛ.fstFieldOfContract a)) (φs.get (φsΛ.sndFieldOfContract a)),
     𝓞.timeContract_mem_center _ _⟩
 
 @[simp]
 lemma timeContract_insertList_none (𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) :
-    (c.insertList φ i none).timeContract 𝓞 = c.timeContract 𝓞 := by
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
+    (φsΛ.insertList φ i none).timeContract 𝓞 = φsΛ.timeContract 𝓞 := by
   rw [timeContract, insertList_none_prod_contractions]
   congr
   ext a
   simp
 
 lemma timeConract_insertList_some (𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (j : c.uncontracted) :
-    (c.insertList φ i (some j)).timeContract 𝓞 =
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
+    (φsΛ.insertList φ i (some j)).timeContract 𝓞 =
     (if i < i.succAbove j then
       ⟨𝓞.timeContract φ φs[j.1], 𝓞.timeContract_mem_center _ _⟩
-    else ⟨𝓞.timeContract φs[j.1] φ, 𝓞.timeContract_mem_center _ _⟩) * c.timeContract 𝓞 := by
+    else ⟨𝓞.timeContract φs[j.1] φ, 𝓞.timeContract_mem_center _ _⟩) * φsΛ.timeContract 𝓞 := by
   rw [timeContract, insertList_some_prod_contractions]
   congr 1
   · simp only [Nat.succ_eq_add_one, insertList_fstFieldOfContract_some_incl, finCongr_apply,
@@ -57,29 +58,29 @@ open FieldStatistic
 
 lemma timeConract_insertList_some_eq_mul_contractStateAtIndex_lt
     (𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (k : c.uncontracted)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
     (ht : 𝓕.timeOrderRel φ φs[k.1]) (hik : i < i.succAbove k) :
-    (c.insertList φ i (some k)).timeContract 𝓞 =
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (c.uncontracted.filter (fun x => x < k))⟩)
-    • (𝓞.contractStateAtIndex φ (List.map φs.get c.uncontractedList)
-    ((uncontractedStatesEquiv φs c) (some k)) * c.timeContract 𝓞) := by
+    (φsΛ.insertList φ i (some k)).timeContract 𝓞 =
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < k))⟩)
+    • (𝓞.contractStateAtIndex φ [φsΛ]ᵘᶜ
+    ((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract 𝓞) := by
   rw [timeConract_insertList_some]
   simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1,
     ProtoOperatorAlgebra.contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
     Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast,
     List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem,
-    Algebra.smul_mul_assoc]
+    Algebra.smul_mul_assoc, uncontractedListGet]
   · simp only [hik, ↓reduceIte, MulMemClass.coe_mul]
     rw [𝓞.timeContract_of_timeOrderRel]
     trans (1 : ℂ) • (𝓞.crAnF ((CrAnAlgebra.superCommute
       (CrAnAlgebra.anPart (StateAlgebra.ofState φ))) (CrAnAlgebra.ofState φs[k.1])) *
-      ↑(timeContract 𝓞 c))
+      ↑(timeContract 𝓞 φsΛ))
     · simp
     simp only [smul_smul]
     congr
-    have h1 : ofList 𝓕.statesStatistic (List.take (↑(c.uncontractedIndexEquiv.symm k))
-        (List.map φs.get c.uncontractedList))
-        = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) c.uncontracted)⟩) := by
+    have h1 : ofList 𝓕.statesStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k))
+        (List.map φs.get φsΛ.uncontractedList))
+        = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) φsΛ.uncontracted)⟩) := by
       simp only [ofFinset]
       congr
       rw [← List.map_take]
@@ -92,25 +93,25 @@ lemma timeConract_insertList_some_eq_mul_contractStateAtIndex_lt
 
 lemma timeConract_insertList_some_eq_mul_contractStateAtIndex_not_lt
     (𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (i : Fin φs.length.succ) (k : c.uncontracted)
+    (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
     (ht : ¬ 𝓕.timeOrderRel φs[k.1] φ) (hik : ¬ i < i.succAbove k) :
-    (c.insertList φ i (some k)).timeContract 𝓞 =
-    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (c.uncontracted.filter (fun x => x ≤ k))⟩)
-    • (𝓞.contractStateAtIndex φ (List.map φs.get c.uncontractedList)
-    ((uncontractedStatesEquiv φs c) (some k)) * c.timeContract 𝓞) := by
+    (φsΛ.insertList φ i (some k)).timeContract 𝓞 =
+    𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x ≤ k))⟩)
+    • (𝓞.contractStateAtIndex φ [φsΛ]ᵘᶜ
+    ((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract 𝓞) := by
   rw [timeConract_insertList_some]
   simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1,
     ProtoOperatorAlgebra.contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
     Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast,
     List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem,
-    Algebra.smul_mul_assoc]
+    Algebra.smul_mul_assoc, uncontractedListGet]
   simp only [hik, ↓reduceIte, MulMemClass.coe_mul]
   rw [𝓞.timeContract_of_not_timeOrderRel, 𝓞.timeContract_of_timeOrderRel]
   simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, smul_smul]
   congr
-  have h1 : ofList 𝓕.statesStatistic (List.take (↑(c.uncontractedIndexEquiv.symm k))
-      (List.map φs.get c.uncontractedList))
-      = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) c.uncontracted)⟩) := by
+  have h1 : ofList 𝓕.statesStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k))
+      (List.map φs.get φsΛ.uncontractedList))
+      = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) φsΛ.uncontracted)⟩) := by
     simp only [ofFinset]
     congr
     rw [← List.map_take]
@@ -143,8 +144,8 @@ lemma timeConract_insertList_some_eq_mul_contractStateAtIndex_not_lt
   exact ht
 
 lemma timeContract_of_not_gradingCompliant (𝓞 : 𝓕.ProtoOperatorAlgebra) (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (h : ¬ GradingCompliant φs c) :
-    c.timeContract 𝓞 = 0 := by
+    (φsΛ : WickContraction φs.length) (h : ¬ GradingCompliant φs φsΛ) :
+    φsΛ.timeContract 𝓞 = 0 := by
   rw [timeContract]
   simp only [GradingCompliant, Fin.getElem_fin, Subtype.forall, not_forall] at h
   obtain ⟨a, ha⟩ := h
diff --git a/HepLean/PerturbationTheory/WickContraction/UncontractedList.lean b/HepLean/PerturbationTheory/WickContraction/UncontractedList.lean
index e3aed04..37f8c90 100644
--- a/HepLean/PerturbationTheory/WickContraction/UncontractedList.lean
+++ b/HepLean/PerturbationTheory/WickContraction/UncontractedList.lean
@@ -281,7 +281,16 @@ lemma take_uncontractedIndexEquiv_symm (k : c.uncontracted) :
     rw [hl]
   rw [uncontractedIndexEquiv_symm_eq_filter_length]
   simp
+/-!
 
+## Uncontracted List get
+
+-/
+
+def uncontractedListGet {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
+    List 𝓕.States := φsΛ.uncontractedList.map φs.get
+
+scoped[WickContraction] notation  "[" φsΛ "]ᵘᶜ" => uncontractedListGet φsΛ
 /-!
 
 ## uncontractedStatesEquiv
@@ -291,20 +300,21 @@ lemma take_uncontractedIndexEquiv_symm (k : c.uncontracted) :
 /-- The equivalence between the type `Option c.uncontracted` for `WickContraction φs.length` and
   `Option (Fin (c.uncontractedList.map φs.get).length)`, that is optional positions of
   `c.uncontractedList.map φs.get` induced by `uncontractedIndexEquiv`. -/
-def uncontractedStatesEquiv (φs : List 𝓕.States) (c : WickContraction φs.length) :
-    Option c.uncontracted ≃ Option (Fin (c.uncontractedList.map φs.get).length) :=
-  Equiv.optionCongr (c.uncontractedIndexEquiv.symm.trans (finCongr (by simp)))
+def uncontractedStatesEquiv (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) :
+    Option φsΛ.uncontracted ≃ Option (Fin [φsΛ]ᵘᶜ.length) :=
+  Equiv.optionCongr (φsΛ.uncontractedIndexEquiv.symm.trans
+    (finCongr (by simp [uncontractedListGet])))
 
 @[simp]
-lemma uncontractedStatesEquiv_none (φs : List 𝓕.States) (c : WickContraction φs.length) :
-    (uncontractedStatesEquiv φs c).toFun none = none := by
+lemma uncontractedStatesEquiv_none (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) :
+    (uncontractedStatesEquiv φs φsΛ).toFun none = none := by
   simp [uncontractedStatesEquiv]
 
 lemma uncontractedStatesEquiv_list_sum [AddCommMonoid α] (φs : List 𝓕.States)
-    (c : WickContraction φs.length) (f : Option (Fin (c.uncontractedList.map φs.get).length) → α) :
-    ∑ (i : Option (Fin (c.uncontractedList.map φs.get).length)), f i =
-    ∑ (i : Option c.uncontracted), f (c.uncontractedStatesEquiv φs i) := by
-  rw [(c.uncontractedStatesEquiv φs).sum_comp]
+    (φsΛ : WickContraction φs.length) (f : Option (Fin [φsΛ]ᵘᶜ.length) → α) :
+    ∑ (i : Option (Fin [φsΛ]ᵘᶜ.length)), f i =
+    ∑ (i : Option φsΛ.uncontracted), f (φsΛ.uncontractedStatesEquiv φs i) := by
+  rw [(φsΛ.uncontractedStatesEquiv φs).sum_comp]
 
 /-!
 
diff --git a/HepLean/PerturbationTheory/WicksTheorem.lean b/HepLean/PerturbationTheory/WicksTheorem.lean
index d5e0d90..d9e099e 100644
--- a/HepLean/PerturbationTheory/WicksTheorem.lean
+++ b/HepLean/PerturbationTheory/WicksTheorem.lean
@@ -31,39 +31,37 @@ We have (roughly) `N(c.insertList φ i none).uncontractedList = s • N(φ * c.u
 Where `s` is the exchange sign for `φ` and the uncontracted fields in `φ₀φ₁…φᵢ`.
 -/
 lemma insertList_none_normalOrder (φ : 𝓕.States) (φs : List 𝓕.States)
-    (i : Fin φs.length.succ) (c : WickContraction φs.length) :
-    𝓞.crAnF (𝓝(ofStateList (List.map (φs.insertIdx i φ).get
-      (c.insertList φ i none).uncontractedList)))
-    = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, c.uncontracted.filter (fun x => i.succAbove x < i)⟩) •
-    𝓞.crAnF (𝓝(ofStateList (optionEraseZ (c.uncontractedList.map φs.get) φ none))) := by
-  simp only [Nat.succ_eq_add_one, instCommGroup.eq_1, optionEraseZ]
-  rw [crAnF_ofState_normalOrder_insert φ (c.uncontractedList.map φs.get)
-    ⟨(c.uncontractedListOrderPos i), by simp⟩, smul_smul]
-  trans (1 : ℂ) • 𝓞.crAnF (𝓝(ofStateList
-    (List.map (List.insertIdx (↑i) φ φs).get (insertList φ c i none).uncontractedList)))
+    (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
+    𝓞.crAnF (𝓝(ofStateList [φsΛ.insertList φ i none]ᵘᶜ))
+    = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => i.succAbove x < i)⟩) •
+    𝓞.crAnF 𝓝(ofStateList (φ :: [φsΛ]ᵘᶜ)) := by
+  simp only [Nat.succ_eq_add_one, instCommGroup.eq_1]
+  rw [crAnF_ofState_normalOrder_insert φ [φsΛ]ᵘᶜ
+    ⟨(φsΛ.uncontractedListOrderPos i), by simp [uncontractedListGet]⟩, smul_smul]
+  trans (1 : ℂ) • 𝓞.crAnF (𝓝(ofStateList [φsΛ.insertList φ i none]ᵘᶜ))
   · simp
   congr 1
-  simp only [instCommGroup.eq_1]
+  simp only [instCommGroup.eq_1, uncontractedListGet]
   rw [← List.map_take, take_uncontractedListOrderPos_eq_filter]
-  have h1 : (𝓕 |>ₛ List.map φs.get (List.filter (fun x => decide (↑x < i.1)) c.uncontractedList))
-        = 𝓕 |>ₛ ⟨φs.get, (c.uncontracted.filter (fun x => x.val < i.1))⟩ := by
+  have h1 : (𝓕 |>ₛ List.map φs.get (List.filter (fun x => decide (↑x < i.1)) φsΛ.uncontractedList))
+        = 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x.val < i.1))⟩ := by
       simp only [Nat.succ_eq_add_one, ofFinset]
       congr
       rw [uncontractedList_eq_sort]
       have hdup : (List.filter (fun x => decide (x.1 < i.1))
-          (Finset.sort (fun x1 x2 => x1 ≤ x2) c.uncontracted)).Nodup := by
-        exact List.Nodup.filter _ (Finset.sort_nodup (fun x1 x2 => x1 ≤ x2) c.uncontracted)
+          (Finset.sort (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)).Nodup := by
+        exact List.Nodup.filter _ (Finset.sort_nodup (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)
       have hsort : (List.filter (fun x => decide (x.1 < i.1))
-          (Finset.sort (fun x1 x2 => x1 ≤ x2) c.uncontracted)).Sorted (· ≤ ·) := by
-        exact List.Sorted.filter _ (Finset.sort_sorted (fun x1 x2 => x1 ≤ x2) c.uncontracted)
+          (Finset.sort (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)).Sorted (· ≤ ·) := by
+        exact List.Sorted.filter _ (Finset.sort_sorted (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)
       rw [← (List.toFinset_sort (· ≤ ·) hdup).mpr hsort]
       congr
       ext a
       simp
   rw [h1]
   simp only [Nat.succ_eq_add_one]
-  have h2 : (Finset.filter (fun x => x.1 < i.1) c.uncontracted) =
-    (Finset.filter (fun x => i.succAbove x < i) c.uncontracted) := by
+  have h2 : (Finset.filter (fun x => x.1 < i.1) φsΛ.uncontracted) =
+    (Finset.filter (fun x => i.succAbove x < i) φsΛ.uncontracted) := by
     ext a
     simp only [Nat.succ_eq_add_one, Finset.mem_filter, and_congr_right_iff]
     intro ha
@@ -103,14 +101,12 @@ is equal to `N((c.uncontractedList).eraseIdx k')`
 where `k'` is the position in `c.uncontractedList` corresponding to `k`.
 -/
 lemma insertList_some_normalOrder (φ : 𝓕.States) (φs : List 𝓕.States)
-    (i : Fin φs.length.succ) (c : WickContraction φs.length) (k : c.uncontracted) :
-    𝓞.crAnF 𝓝(ofStateList (List.map (φs.insertIdx i φ).get
-      (c.insertList φ i (some k)).uncontractedList))
-    = 𝓞.crAnF 𝓝(ofStateList (optionEraseZ (c.uncontractedList.map φs.get) φ
-    ((uncontractedStatesEquiv φs c) k))) := by
+    (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) :
+    𝓞.crAnF 𝓝(ofStateList [φsΛ.insertList φ i (some k)]ᵘᶜ)
+    = 𝓞.crAnF 𝓝(ofStateList (optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedStatesEquiv φs φsΛ) k))) := by
   simp only [Nat.succ_eq_add_one, insertList, optionEraseZ, uncontractedStatesEquiv,
     Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply,
-    Fin.coe_cast]
+    Fin.coe_cast, uncontractedListGet]
   congr
   rw [congr_uncontractedList]
   erw [uncontractedList_extractEquiv_symm_some]
@@ -125,14 +121,12 @@ for `c` equal to `c.insertList φ i none` is equal to that for just `c`
 mulitiplied by the exchange sign of `φ` and `φ₀φ₁…φᵢ₋₁`.
 -/
 lemma sign_timeContract_normalOrder_insertList_none (φ : 𝓕.States) (φs : List 𝓕.States)
-    (i : Fin φs.length.succ) (c : WickContraction φs.length) :
-    (c.insertList φ i none).sign • (c.insertList φ i none).timeContract 𝓞
-    * 𝓞.crAnF 𝓝(ofStateList (List.map (φs.insertIdx i φ).get
-      (c.insertList φ i none).uncontractedList)) =
+    (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
+    (φsΛ.insertList φ i none).sign • (φsΛ.insertList φ i none).timeContract 𝓞
+    * 𝓞.crAnF 𝓝(ofStateList [φsΛ.insertList φ i none]ᵘᶜ) =
     𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun k => i.succAbove k < i))⟩)
-    • (c.sign • c.timeContract 𝓞 *
-      𝓞.crAnF 𝓝(ofStateList (optionEraseZ (c.uncontractedList.map φs.get) φ none))) := by
-  by_cases hg : GradingCompliant φs c
+    • (φsΛ.sign • φsΛ.timeContract 𝓞 * 𝓞.crAnF 𝓝(ofStateList (φ :: [φsΛ]ᵘᶜ))) := by
+  by_cases hg : GradingCompliant φs φsΛ
   · rw [insertList_none_normalOrder, sign_insert_none]
     simp only [Nat.succ_eq_add_one, timeContract_insertList_none, instCommGroup.eq_1,
       Algebra.mul_smul_comm, Algebra.smul_mul_assoc, smul_smul]
@@ -155,7 +149,7 @@ lemma sign_timeContract_normalOrder_insertList_none (φ : 𝓕.States) (φs : Li
     · intro ha
       simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and, ha, and_true,
         forall_const]
-      have hx : c.getDual? a = none ↔ ¬ (c.getDual? a).isSome := by
+      have hx : φsΛ.getDual? a = none ↔ ¬ (φsΛ.getDual? a).isSome := by
         simp
       rw [hx]
       simp only [Bool.not_eq_true, Bool.eq_false_or_eq_true_self, true_and]
@@ -175,18 +169,17 @@ for `c` equal to `c.insertList φ i (some k)` is equal to that for just `c`
 mulitiplied by the exchange sign of `φ` and `φ₀φ₁…φᵢ₋₁`.
 -/
 lemma sign_timeContract_normalOrder_insertList_some (φ : 𝓕.States) (φs : List 𝓕.States)
-    (i : Fin φs.length.succ) (c : WickContraction φs.length) (k : c.uncontracted)
+    (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted)
     (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k])
     (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬ timeOrderRel φs[k] φ) :
-    (c.insertList φ i (some k)).sign • (c.insertList φ i (some k)).timeContract 𝓞
-    * 𝓞.crAnF 𝓝(ofStateList (List.map (φs.insertIdx i φ).get
-      (c.insertList φ i (some k)).uncontractedList)) =
+    (φsΛ.insertList φ i (some k)).sign • (φsΛ.insertList φ i (some k)).timeContract 𝓞
+    * 𝓞.crAnF 𝓝(ofStateList [φsΛ.insertList φ i (some k)]ᵘᶜ) =
     𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩)
-    • (c.sign • (𝓞.contractStateAtIndex φ (List.map φs.get c.uncontractedList)
-      ((uncontractedStatesEquiv φs c) (some k)) * c.timeContract 𝓞)
-    * 𝓞.crAnF 𝓝(ofStateList (optionEraseZ (c.uncontractedList.map φs.get) φ
-      ((uncontractedStatesEquiv φs c) k)))) := by
-  by_cases hg : GradingCompliant φs c ∧ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[k.1])
+    • (φsΛ.sign • (𝓞.contractStateAtIndex φ [φsΛ]ᵘᶜ
+      ((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract 𝓞)
+    * 𝓞.crAnF 𝓝(ofStateList (optionEraseZ [φsΛ]ᵘᶜ φ
+      ((uncontractedStatesEquiv φs φsΛ) k)))) := by
+  by_cases hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[k.1])
   · by_cases hk : i.succAbove k < i
     · rw [WickContraction.timeConract_insertList_some_eq_mul_contractStateAtIndex_not_lt]
       swap
@@ -194,9 +187,9 @@ lemma sign_timeContract_normalOrder_insertList_some (φ : 𝓕.States) (φs : Li
       rw [insertList_some_normalOrder, sign_insert_some]
       simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc]
       congr 1
-      rw [mul_assoc, mul_comm (sign φs c), ← mul_assoc]
+      rw [mul_assoc, mul_comm (sign φs φsΛ), ← mul_assoc]
       congr 1
-      exact signInsertSome_mul_filter_contracted_of_lt φ φs c i k hk hg
+      exact signInsertSome_mul_filter_contracted_of_lt φ φs φsΛ i k hk hg
       · omega
     · have hik : i.succAbove ↑k ≠ i := Fin.succAbove_ne i ↑k
       rw [WickContraction.timeConract_insertList_some_eq_mul_contractStateAtIndex_lt]
@@ -206,18 +199,19 @@ lemma sign_timeContract_normalOrder_insertList_some (φ : 𝓕.States) (φs : Li
       rw [sign_insert_some]
       simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc]
       congr 1
-      rw [mul_assoc, mul_comm (sign φs c), ← mul_assoc]
+      rw [mul_assoc, mul_comm (sign φs φsΛ), ← mul_assoc]
       congr 1
-      exact signInsertSome_mul_filter_contracted_of_not_lt φ φs c i k hk hg
+      exact signInsertSome_mul_filter_contracted_of_not_lt φ φs φsΛ i k hk hg
       · omega
   · rw [timeConract_insertList_some]
     simp only [Fin.getElem_fin, not_and] at hg
-    by_cases hg' : GradingCompliant φs c
+    by_cases hg' : GradingCompliant φs φsΛ
     · have hg := hg hg'
       simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, Algebra.smul_mul_assoc,
         instCommGroup.eq_1, contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
         Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast,
-        List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem]
+        List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem,
+        uncontractedListGet]
       by_cases h1 : i < i.succAbove ↑k
       · simp only [h1, ↓reduceIte, MulMemClass.coe_mul]
         rw [timeContract_zero_of_diff_grade]
@@ -248,15 +242,12 @@ for all `c' = (c.insertList φ i k)` for `k : Option (c.uncontracted)`, multipli
 the exchange sign of `φ` and `φ₀φ₁…φᵢ₋₁`.
 -/
 lemma mul_sum_contractions (φ : 𝓕.States) (φs : List 𝓕.States) (i : Fin φs.length.succ)
-    (c : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k])
+    (φsΛ : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k])
     (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬timeOrderRel φs[k] φ) :
-    (c.sign • c.timeContract 𝓞) * 𝓞.crAnF ((CrAnAlgebra.ofState φ) *
-      𝓝(ofStateList (c.uncontractedList.map φs.get))) =
+    (φsΛ.sign • φsΛ.timeContract 𝓞) * 𝓞.crAnF ((CrAnAlgebra.ofState φ) * 𝓝(ofStateList [φsΛ]ᵘᶜ)) =
     𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩) •
-    ∑ (k : Option (c.uncontracted)),
-    ((c.insertList φ i k).sign • (c.insertList φ i k).timeContract 𝓞
-    * 𝓞.crAnF (𝓝(ofStateList
-      ((c.insertList φ i k).uncontractedList.map (φs.insertIdx i φ).get)))) := by
+    ∑ (k : Option φsΛ.uncontracted), ((φsΛ.insertList φ i k).sign •
+    (φsΛ.insertList φ i k).timeContract 𝓞 * 𝓞.crAnF (𝓝(ofStateList [φsΛ.insertList φ i k]ᵘᶜ))) := by
   rw [crAnF_ofState_mul_normalOrder_ofStatesList_eq_sum, Finset.mul_sum,
     uncontractedStatesEquiv_list_sum, Finset.smul_sum]
   simp only [instCommGroup.eq_1, Nat.succ_eq_add_one]
@@ -281,15 +272,15 @@ lemma mul_sum_contractions (φ : 𝓕.States) (φs : List 𝓕.States) (i : Fin
       rw [one_mul]
     · rw [← mul_assoc]
       congr 1
-      have ht := (WickContraction.timeContract 𝓞 c).prop
+      have ht := (WickContraction.timeContract 𝓞 φsΛ).prop
       rw [@Subalgebra.mem_center_iff] at ht
       rw [ht]
 
 lemma wicks_theorem_congr {φs φs' : List 𝓕.States} (h : φs = φs') :
-    ∑ (c : WickContraction φs.length), (c.sign • c.timeContract 𝓞) *
-      𝓞.crAnF 𝓝(ofStateList (c.uncontractedList.map φs.get))
-    = ∑ (c : WickContraction φs'.length), (c.sign • c.timeContract 𝓞) *
-      𝓞.crAnF 𝓝(ofStateList (c.uncontractedList.map φs'.get)) := by
+    ∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract 𝓞) *
+      𝓞.crAnF 𝓝(ofStateList [φsΛ]ᵘᶜ)
+    = ∑ (φs'Λ : WickContraction φs'.length), (φs'Λ.sign • φs'Λ.timeContract 𝓞) *
+      𝓞.crAnF 𝓝(ofStateList [φs'Λ]ᵘᶜ) := by
   subst h
   simp
 
@@ -301,12 +292,12 @@ lemma wicks_theorem_congr {φs φs' : List 𝓕.States} (h : φs = φs') :
 
 /-- Wick's theorem for the empty list. -/
 lemma wicks_theorem_nil :
-    𝓞.crAnF (ofStateAlgebra (timeOrder (ofList []))) = ∑ (c : WickContraction [].length),
-    (c.sign [] • c.timeContract 𝓞) *
-    𝓞.crAnF 𝓝(ofStateList (c.uncontractedList.map [].get)) := by
+    𝓞.crAnF (ofStateAlgebra (timeOrder (ofList []))) = ∑ (nilΛ : WickContraction [].length),
+    (nilΛ.sign • nilΛ.timeContract 𝓞) *
+    𝓞.crAnF 𝓝(ofStateList [nilΛ]ᵘᶜ) := by
   rw [timeOrder_ofList_nil]
   simp only [map_one, List.length_nil, Algebra.smul_mul_assoc]
-  rw [sum_WickContraction_nil, nil_zero_uncontractedList]
+  rw [sum_WickContraction_nil, uncontractedListGet, nil_zero_uncontractedList]
   simp only [List.map_nil]
   have h1 : ofStateList (𝓕 := 𝓕) [] = CrAnAlgebra.ofCrAnList [] := by simp
   rw [h1, normalOrder_ofCrAnList]
@@ -329,8 +320,8 @@ remark wicks_theorem_context := "
 - The normal-ordering of the uncontracted fields in `c`.
 -/
 theorem wicks_theorem : (φs : List 𝓕.States) → 𝓞.crAnF (ofStateAlgebra (timeOrder (ofList φs))) =
-    ∑ (c : WickContraction φs.length), (c.sign φs • c.timeContract 𝓞) *
-      𝓞.crAnF 𝓝(ofStateList (c.uncontractedList.map φs.get))
+    ∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract 𝓞) *
+    𝓞.crAnF 𝓝(ofStateList [φsΛ]ᵘᶜ)
   | [] => wicks_theorem_nil
   | φ :: φs => by
     have ih := wicks_theorem (eraseMaxTimeField φ φs)
@@ -358,11 +349,11 @@ theorem wicks_theorem : (φs : List 𝓕.States) → 𝓞.crAnF (ofStateAlgebra
         (insertList (maxTimeField φ φs) c
         (maxTimeFieldPosFin φ φs) k).uncontractedList))
     swap
-    · simp
+    · simp [uncontractedListGet]
     rw [smul_smul]
     simp only [instCommGroup.eq_1, exchangeSign_mul_self, Nat.succ_eq_add_one,
       Algebra.smul_mul_assoc, Fintype.sum_option, timeContract_insertList_none,
-      Finset.univ_eq_attach, smul_add, one_smul]
+      Finset.univ_eq_attach, smul_add, one_smul, uncontractedListGet]
     · exact fun k => timeOrder_maxTimeField _ _ k
     · exact fun k => lt_maxTimeFieldPosFin_not_timeOrder _ _ k
 termination_by φs => φs.length