refactor: Change in contraction notation
This commit is contained in:
jstoobysmith
parent
6701ee7b37
commit
321e69e52e
5 changed files with 326 additions and 324 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
||||
/-!
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue