feat: Property of time-order w.r.t. superCommute
This commit is contained in:
jstoobysmith
parent
a79d0f8fed
commit
c2d89cc093
8 changed files with 781 additions and 8 deletions
|
|
@ -150,6 +150,15 @@ lemma insertionSort_insertionSort_append {α : Type} (r : α → α → Prop) [D
|
|||
simp
|
||||
rw [insertionSort_insertionSort_append r l1 l2]
|
||||
|
||||
lemma insertionSort_append_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] : (l1 l2 l3 : List α) →
|
||||
List.insertionSort r (l1 ++ List.insertionSort r l2 ++ l3) = List.insertionSort r (l1 ++ l2 ++ l3)
|
||||
| [], l2, l3 => by
|
||||
simp
|
||||
exact insertionSort_insertionSort_append r l2 l3
|
||||
| a :: l1, l2, l3 => by
|
||||
simp only [List.insertionSort, List.append_eq]
|
||||
rw [insertionSort_append_insertionSort_append r l1 l2 l3]
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsert_length {α : Type} (r : α → α → Prop) [DecidableRel r] (a : α) (l : List α) :
|
||||
|
|
@ -210,12 +219,6 @@ lemma takeWhile_orderedInsert' {α : Type} (r : α → α → Prop) [DecidableRe
|
|||
· simp [hac, h]
|
||||
exact takeWhile_orderedInsert' r a b hr l
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
lemma insertionSortEquiv_commute {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a b : α) (hr : ¬ r a b) (n : ℕ) : (l : List α) →
|
||||
(hn : n + 2 < (a :: b :: l).length) →
|
||||
|
|
@ -373,8 +376,271 @@ lemma insertionSortEquiv_insertionSort_append {α : Type} (r : α → α → Pro
|
|||
simp
|
||||
|
||||
|
||||
/-!
|
||||
|
||||
## Insertion sort with equal fields
|
||||
|
||||
-/
|
||||
|
||||
lemma orderedInsert_filter_of_pos {α : Type} (r : α → α → Prop) [DecidableRel r] [IsTotal α r]
|
||||
[IsTrans α r] (a : α) (p : α → Prop) [DecidablePred p] (h : p a) : (l : List α) →
|
||||
(hl : l.Sorted r) →
|
||||
List.filter p (List.orderedInsert r a l) = List.orderedInsert r a (List.filter p l)
|
||||
| [], hl => by
|
||||
simp
|
||||
exact h
|
||||
| b :: l, hl => by
|
||||
simp
|
||||
by_cases hpb : p b <;> by_cases hab : r a b
|
||||
· simp [hpb, hab]
|
||||
rw [List.filter_cons_of_pos (by simp [h])]
|
||||
rw [List.filter_cons_of_pos (by simp [hpb])]
|
||||
· simp [hab]
|
||||
rw [List.filter_cons_of_pos (by simp [hpb])]
|
||||
rw [List.filter_cons_of_pos (by simp [hpb])]
|
||||
simp [hab]
|
||||
simp at hl
|
||||
exact orderedInsert_filter_of_pos r a p h l hl.2
|
||||
· simp [hab]
|
||||
rw [List.filter_cons_of_pos (by simp [h]),
|
||||
List.filter_cons_of_neg (by simp [hpb])]
|
||||
rw [List.orderedInsert_eq_take_drop]
|
||||
have hl : List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = [] := by
|
||||
rw [List.takeWhile_eq_nil_iff]
|
||||
intro c hc
|
||||
simp at hc
|
||||
apply hc
|
||||
apply IsTrans.trans a b _ hab
|
||||
simp at hl
|
||||
apply hl.1
|
||||
have hlf : (List.filter (fun b => decide (p b)) l)[0] ∈ (List.filter (fun b => decide (p b)) l) := by
|
||||
exact List.getElem_mem c
|
||||
simp [- List.getElem_mem] at hlf
|
||||
exact hlf.1
|
||||
rw [hl]
|
||||
simp
|
||||
conv_lhs => rw [← List.takeWhile_append_dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l )]
|
||||
rw [hl]
|
||||
simp
|
||||
· simp [hab]
|
||||
rw [List.filter_cons_of_neg (by simp [hpb])]
|
||||
rw [List.filter_cons_of_neg (by simp [hpb])]
|
||||
simp at hl
|
||||
exact orderedInsert_filter_of_pos r a p h l hl.2
|
||||
|
||||
lemma orderedInsert_filter_of_neg {α : Type} (r : α → α → Prop) [DecidableRel r] [IsTotal α r]
|
||||
[IsTrans α r] (a : α) (p : α → Prop) [DecidablePred p] (h : ¬ p a) (l : List α) :
|
||||
List.filter p (List.orderedInsert r a l) = (List.filter p l) := by
|
||||
rw [List.orderedInsert_eq_take_drop]
|
||||
simp
|
||||
rw [List.filter_cons_of_neg]
|
||||
rw [← List.filter_append]
|
||||
congr
|
||||
exact List.takeWhile_append_dropWhile (fun b => !decide (r a b)) l
|
||||
simp [h]
|
||||
|
||||
|
||||
|
||||
lemma insertionSort_filter {α : Type} (r : α → α → Prop) [DecidableRel r] [IsTotal α r]
|
||||
[IsTrans α r] (p : α → Prop) [DecidablePred p] : (l : List α) →
|
||||
List.insertionSort r (List.filter p l) =
|
||||
List.filter p (List.insertionSort r l)
|
||||
| [] => by simp
|
||||
| a :: l => by
|
||||
simp
|
||||
by_cases h : p a
|
||||
· rw [orderedInsert_filter_of_pos]
|
||||
rw [List.filter_cons_of_pos]
|
||||
simp
|
||||
rw [insertionSort_filter]
|
||||
simp_all
|
||||
simp_all
|
||||
exact List.sorted_insertionSort r l
|
||||
· rw [orderedInsert_filter_of_neg]
|
||||
rw [List.filter_cons_of_neg]
|
||||
rw [insertionSort_filter]
|
||||
simp_all
|
||||
exact h
|
||||
|
||||
lemma takeWhile_sorted_eq_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) : (l : List α) → (hl : l.Sorted r) →
|
||||
List.takeWhile (fun c => ¬ r a c) l = List.filter (fun c => ¬ r a c) l
|
||||
| [], _ => by simp
|
||||
| b :: l, hl => by
|
||||
simp at hl
|
||||
by_cases hb : ¬ r a b
|
||||
· simp [hb]
|
||||
simpa using takeWhile_sorted_eq_filter r a l hl.2
|
||||
· simp_all
|
||||
intro c hc
|
||||
apply IsTrans.trans a b c hb
|
||||
exact hl.1 c hc
|
||||
|
||||
lemma dropWhile_sorted_eq_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) : (l : List α) → (hl : l.Sorted r) →
|
||||
List.dropWhile (fun c => ¬ r a c) l = List.filter (fun c => r a c) l
|
||||
| [], _ => by simp
|
||||
| b :: l, hl => by
|
||||
simp at hl
|
||||
by_cases hb : ¬ r a b
|
||||
· simp [hb]
|
||||
simpa using dropWhile_sorted_eq_filter r a l hl.2
|
||||
· simp_all
|
||||
symm
|
||||
rw [List.filter_eq_self]
|
||||
intro c hc
|
||||
simp
|
||||
apply IsTrans.trans a b c hb
|
||||
exact hl.1 c hc
|
||||
|
||||
lemma dropWhile_sorted_eq_filter_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) :(l : List α) → (hl : l.Sorted r) →
|
||||
List.filter (fun c => r a c) l =
|
||||
List.filter (fun c => r a c ∧ r c a) l ++ List.filter (fun c => r a c ∧ ¬ r c a) l
|
||||
| [], _ => by
|
||||
simp
|
||||
| b :: l, hl => by
|
||||
simp at hl
|
||||
by_cases hb : ¬ r a b
|
||||
· simp [hb]
|
||||
simpa using dropWhile_sorted_eq_filter_filter r a l hl.2
|
||||
· simp_all
|
||||
by_cases hba : r b a
|
||||
· simp [hba]
|
||||
rw [List.filter_cons_of_pos]
|
||||
rw [dropWhile_sorted_eq_filter_filter]
|
||||
simp
|
||||
exact hl.2
|
||||
simp_all
|
||||
· simp[hba]
|
||||
have h1 : List.filter (fun c => decide (r a c) && decide (r c a)) l = [] := by
|
||||
rw [@List.filter_eq_nil_iff]
|
||||
intro c hc
|
||||
simp
|
||||
intro hac hca
|
||||
apply hba
|
||||
apply IsTrans.trans b c a _ hca
|
||||
exact hl.1 c hc
|
||||
rw [h1]
|
||||
rw [dropWhile_sorted_eq_filter_filter]
|
||||
simp [h1]
|
||||
rw [List.filter_cons_of_pos]
|
||||
simp_all
|
||||
exact hl.2
|
||||
|
||||
lemma filter_rel_eq_insertionSort {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) :(l : List α) →
|
||||
List.filter (fun c => r a c ∧ r c a) (l.insertionSort r) =
|
||||
List.filter (fun c => r a c ∧ r c a) l
|
||||
| [] => by simp
|
||||
| b :: l => by
|
||||
simp only [ List.insertionSort]
|
||||
by_cases h : r a b ∧ r b a
|
||||
· have hl := orderedInsert_filter_of_pos r b (fun c => r a c ∧ r c a) h (List.insertionSort r l)
|
||||
(by exact List.sorted_insertionSort r l)
|
||||
simp at hl ⊢
|
||||
rw [hl]
|
||||
rw [List.orderedInsert_eq_take_drop]
|
||||
have ht : List.takeWhile (fun b_1 => decide ¬r b b_1)
|
||||
(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) = [] := by
|
||||
rw [List.takeWhile_eq_nil_iff]
|
||||
intro hl
|
||||
simp
|
||||
have hx := List.getElem_mem hl
|
||||
simp [- List.getElem_mem] at hx
|
||||
apply IsTrans.trans b a _ h.2
|
||||
simp_all
|
||||
rw [ht]
|
||||
simp
|
||||
rw [List.filter_cons_of_pos]
|
||||
simp
|
||||
have ih := filter_rel_eq_insertionSort r a l
|
||||
simp at ih
|
||||
rw [← ih]
|
||||
have htd := List.takeWhile_append_dropWhile (fun b_1 => decide ¬r b b_1) (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))
|
||||
simp [decide_not, - List.takeWhile_append_dropWhile] at htd
|
||||
conv_rhs => rw [← htd]
|
||||
simp [- List.takeWhile_append_dropWhile]
|
||||
intro hl
|
||||
have hx := List.getElem_mem hl
|
||||
simp [- List.getElem_mem] at hx
|
||||
apply IsTrans.trans b a _ h.2
|
||||
simp_all
|
||||
simp_all
|
||||
· have hl := orderedInsert_filter_of_neg r b (fun c => r a c ∧ r c a) h (List.insertionSort r l)
|
||||
simp at hl ⊢
|
||||
rw [hl]
|
||||
rw [List.filter_cons_of_neg]
|
||||
have ih := filter_rel_eq_insertionSort r a l
|
||||
simp_all
|
||||
simpa using h
|
||||
|
||||
|
||||
lemma insertionSort_of_eq_list {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) (l1 l l2 : List α)
|
||||
(h : ∀ b ∈ l, r a b ∧ r b a) :
|
||||
List.insertionSort r (l1 ++ l ++ l2) =
|
||||
(List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r))
|
||||
++ (List.filter (fun c => r a c ∧ r c a) l1)
|
||||
++ l
|
||||
++ (List.filter (fun c => r a c ∧ r c a) l2)
|
||||
++ (List.filter (fun c => r a c ∧ ¬ r c a) ((l1 ++ l2).insertionSort r))
|
||||
:= by
|
||||
have hl : List.insertionSort r (l1 ++ l ++ l2) =
|
||||
List.takeWhile (fun c => ¬ r a c) ((l1 ++ l ++ l2).insertionSort r) ++
|
||||
List.dropWhile (fun c => ¬ r a c) ((l1 ++ l ++ l2).insertionSort r) := by
|
||||
exact (List.takeWhile_append_dropWhile (fun c => decide ¬r a c)
|
||||
(List.insertionSort r (l1 ++ l ++ l2))).symm
|
||||
have hlt : List.takeWhile (fun c => ¬ r a c) ((l1 ++ l ++ l2).insertionSort r)
|
||||
= List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r) := by
|
||||
rw [takeWhile_sorted_eq_filter, takeWhile_sorted_eq_filter ]
|
||||
rw [← insertionSort_filter, ← insertionSort_filter]
|
||||
congr 1
|
||||
simp
|
||||
exact fun b hb => (h b hb).1
|
||||
exact List.sorted_insertionSort r (l1 ++ l2)
|
||||
exact List.sorted_insertionSort r (l1 ++ l ++ l2)
|
||||
conv_lhs => rw [hl, hlt]
|
||||
simp only [decide_not, Bool.decide_and]
|
||||
simp
|
||||
have h1 := dropWhile_sorted_eq_filter r a (List.insertionSort r (l1 ++ (l ++ l2)))
|
||||
simp at h1
|
||||
rw [h1]
|
||||
rw [dropWhile_sorted_eq_filter_filter, filter_rel_eq_insertionSort]
|
||||
simp
|
||||
congr 1
|
||||
simp
|
||||
exact fun a a_1 => h a a_1
|
||||
congr 1
|
||||
have h1 := insertionSort_filter r (fun c => decide (r a c) && !decide (r c a)) (l1 ++ (l ++ l2))
|
||||
simp at h1
|
||||
rw [← h1]
|
||||
have h2 := insertionSort_filter r (fun c => decide (r a c) && !decide (r c a)) (l1 ++ l2)
|
||||
simp at h2
|
||||
rw [← h2]
|
||||
congr
|
||||
have hl : List.filter (fun b => decide (r a b) && !decide (r b a)) l = [] := by
|
||||
rw [@List.filter_eq_nil_iff]
|
||||
intro c hc
|
||||
simp_all
|
||||
rw [hl]
|
||||
simp
|
||||
exact List.sorted_insertionSort r (l1 ++ (l ++ l2))
|
||||
exact List.sorted_insertionSort r (l1 ++ (l ++ l2))
|
||||
|
||||
lemma insertionSort_of_takeWhile_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) (l1 l2 : List α) :
|
||||
List.insertionSort r (l1 ++ l2) =
|
||||
(List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r))
|
||||
++ (List.filter (fun c => r a c ∧ r c a) l1)
|
||||
++ (List.filter (fun c => r a c ∧ r c a) l2)
|
||||
++ (List.filter (fun c => r a c ∧ ¬ r c a) ((l1 ++ l2).insertionSort r))
|
||||
:= by
|
||||
trans List.insertionSort r (l1 ++ [] ++ l2)
|
||||
simp
|
||||
rw [insertionSort_of_eq_list r a l1 [] l2]
|
||||
simp
|
||||
simp
|
||||
|
||||
|
||||
end HepLean.List
|
||||
|
|
|
|||
|
|
@ -439,6 +439,40 @@ lemma superCommute_ofCrAnList_ofStateList_eq_sum (φs : List 𝓕.CrAnStates) :
|
|||
· simp
|
||||
· simp [Finset.mul_sum, smul_smul, ofStateList_cons, mul_assoc,
|
||||
FieldStatistic.ofList_cons_eq_mul, mul_comm]
|
||||
|
||||
lemma summerCommute_jacobi_ofCrAnList (φs1 φs2 φs3 : List 𝓕.CrAnStates) :
|
||||
[ofCrAnList φs1, [ofCrAnList φs2, ofCrAnList φs3]ₛca]ₛca =
|
||||
𝓢(𝓕 |>ₛ φs1, 𝓕 |>ₛ φs3) •
|
||||
(- 𝓢(𝓕 |>ₛ φs2, 𝓕 |>ₛ φs3 ) • [ofCrAnList φs3, [ofCrAnList φs1, ofCrAnList φs2]ₛca]ₛca -
|
||||
𝓢(𝓕 |>ₛ φs1, 𝓕 |>ₛ φs2) • [ofCrAnList φs2, [ofCrAnList φs3, ofCrAnList φs1]ₛca]ₛca) := by
|
||||
repeat rw [superCommute_ofCrAnList_ofCrAnList]
|
||||
simp
|
||||
repeat rw [superCommute_ofCrAnList_ofCrAnList]
|
||||
simp only [instCommGroup.eq_1, ofList_append_eq_mul, List.append_assoc]
|
||||
by_cases h1 : (𝓕 |>ₛ φs1) = bosonic <;>
|
||||
by_cases h2 : (𝓕 |>ₛ φs2) = bosonic <;>
|
||||
by_cases h3 : (𝓕 |>ₛ φs3) = bosonic
|
||||
· simp [h1, h2, exchangeSign_bosonic, h3, mul_one, one_smul]
|
||||
abel
|
||||
· simp [h1, h2, exchangeSign_bosonic, bosonic_exchangeSign, mul_one, one_smul]
|
||||
abel
|
||||
· simp [h1, bosonic_exchangeSign, h3, exchangeSign_bosonic, mul_one, one_smul]
|
||||
abel
|
||||
· simp at h1 h2 h3
|
||||
simp [h1, h2, h3]
|
||||
abel
|
||||
· simp at h1 h2 h3
|
||||
simp [h1, h2, h3]
|
||||
abel
|
||||
· simp at h1 h2 h3
|
||||
simp [h1, h2, h3]
|
||||
abel
|
||||
· simp at h1 h2 h3
|
||||
simp [h1, h2, h3]
|
||||
abel
|
||||
· simp at h1 h2 h3
|
||||
simp [h1, h2, h3]
|
||||
abel
|
||||
/-!
|
||||
|
||||
## Interaction with grading.
|
||||
|
|
|
|||
|
|
@ -39,6 +39,66 @@ lemma timeOrder_ofCrAnList (φs : List 𝓕.CrAnStates) :
|
|||
rw [← ofListBasis_eq_ofList]
|
||||
simp only [timeOrder, Basis.constr_basis]
|
||||
|
||||
lemma timeOrder_timeOrder_mid (a b c : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b * c) = 𝓣ᶠ(a * 𝓣ᶠ(b) * c) := by
|
||||
let pc (c : 𝓕.CrAnAlgebra) (hc : c ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
|
||||
Prop := 𝓣ᶠ(a * b * c) = 𝓣ᶠ(a * 𝓣ᶠ(b) * c)
|
||||
change pc c (Basis.mem_span _ c)
|
||||
apply Submodule.span_induction
|
||||
· intro x hx
|
||||
obtain ⟨φs, rfl⟩ := hx
|
||||
simp [pc]
|
||||
let pb (b : 𝓕.CrAnAlgebra) (hb : b ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
|
||||
Prop := 𝓣ᶠ(a * b * ofCrAnList φs) = 𝓣ᶠ(a * 𝓣ᶠ(b) * ofCrAnList φs)
|
||||
change pb b (Basis.mem_span _ b)
|
||||
apply Submodule.span_induction
|
||||
· intro x hx
|
||||
obtain ⟨φs', rfl⟩ := hx
|
||||
simp [pb]
|
||||
let pa (a : 𝓕.CrAnAlgebra) (ha : a ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
|
||||
Prop := 𝓣ᶠ(a * ofCrAnList φs' * ofCrAnList φs) = 𝓣ᶠ(a * 𝓣ᶠ(ofCrAnList φs') * ofCrAnList φs)
|
||||
change pa a (Basis.mem_span _ a)
|
||||
apply Submodule.span_induction
|
||||
· intro x hx
|
||||
obtain ⟨φs'', rfl⟩ := hx
|
||||
simp [pa]
|
||||
rw [timeOrder_ofCrAnList]
|
||||
simp only [← ofCrAnList_append, Algebra.mul_smul_comm,
|
||||
Algebra.smul_mul_assoc, map_smul]
|
||||
rw [timeOrder_ofCrAnList, timeOrder_ofCrAnList, smul_smul]
|
||||
congr 1
|
||||
· simp only [crAnTimeOrderSign, crAnTimeOrderList]
|
||||
rw [Wick.koszulSign_of_append_eq_insertionSort, mul_comm]
|
||||
· congr 1
|
||||
simp only [crAnTimeOrderList]
|
||||
rw [insertionSort_append_insertionSort_append]
|
||||
· simp [pa]
|
||||
· intro x y hx hy h1 h2
|
||||
simp_all [pa, add_mul]
|
||||
· intro x hx h
|
||||
simp_all [pa]
|
||||
· simp [pb]
|
||||
· intro x y hx hy h1 h2
|
||||
simp_all [pb, mul_add, add_mul]
|
||||
· intro x hx h
|
||||
simp_all [pb]
|
||||
· simp [pc]
|
||||
· intro x y hx hy h1 h2
|
||||
simp_all [pc, mul_add]
|
||||
· intro x hx h hp
|
||||
simp_all [pc]
|
||||
|
||||
lemma timeOrder_timeOrder_right (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(a * 𝓣ᶠ(b)) := by
|
||||
trans 𝓣ᶠ(a * b * 1)
|
||||
· simp
|
||||
· rw [timeOrder_timeOrder_mid]
|
||||
simp
|
||||
|
||||
lemma timeOrder_timeOrder_left (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(𝓣ᶠ(a) * b) := by
|
||||
trans 𝓣ᶠ(1 * a * b)
|
||||
· simp
|
||||
· rw [timeOrder_timeOrder_mid]
|
||||
simp
|
||||
|
||||
lemma timeOrder_ofStateList (φs : List 𝓕.States) :
|
||||
𝓣ᶠ(ofStateList φs) = timeOrderSign φs • ofStateList (timeOrderList φs) := by
|
||||
conv_lhs =>
|
||||
|
|
@ -100,6 +160,119 @@ lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel
|
|||
· rw [crAnTimeOrderList_pair_ordered]
|
||||
simp_all
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right
|
||||
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.CrAnAlgebra) :
|
||||
𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca) = 0 := by
|
||||
rw [timeOrder_timeOrder_right,
|
||||
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
|
||||
simp
|
||||
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left
|
||||
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.CrAnAlgebra) :
|
||||
𝓣ᶠ([ofCrAnState φ, ofCrAnState ψ]ₛca * a) = 0 := by
|
||||
rw [timeOrder_timeOrder_left,
|
||||
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
|
||||
simp
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_mid
|
||||
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a b : 𝓕.CrAnAlgebra) :
|
||||
𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) = 0 := by
|
||||
rw [timeOrder_timeOrder_mid,
|
||||
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
|
||||
simp
|
||||
|
||||
lemma timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel
|
||||
{φ1 φ2 : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ1 φ2) (a : 𝓕.CrAnAlgebra):
|
||||
𝓣ᶠ([a, [ofCrAnState φ1, ofCrAnState φ2]ₛca]ₛca) = 0 := by
|
||||
rw [← bosonicProj_add_fermionicProj a]
|
||||
simp
|
||||
rw [bosonic_superCommute (Submodule.coe_mem (bosonicProj a))]
|
||||
simp
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
|
||||
simp
|
||||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton]
|
||||
rcases superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h' | h'
|
||||
· rw [superCommute_bonsonic h']
|
||||
simp [ofCrAnList_singleton]
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
|
||||
simp
|
||||
· rw [superCommute_fermionic_fermionic (Submodule.coe_mem (fermionicProj a)) h']
|
||||
simp [ofCrAnList_singleton]
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
|
||||
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
|
||||
simp
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel
|
||||
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ1 φ2)
|
||||
(h13 : ¬ crAnTimeOrderRel φ1 φ3) :
|
||||
𝓣ᶠ([ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca) = 0 := by
|
||||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_singleton]
|
||||
rw [summerCommute_jacobi_ofCrAnList]
|
||||
simp [ofCrAnList_singleton]
|
||||
right
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h12 ]
|
||||
rw [superCommute_ofCrAnState_ofCrAnState_symm φ3]
|
||||
simp
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h13]
|
||||
simp
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel'
|
||||
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ2 φ1)
|
||||
(h13 : ¬ crAnTimeOrderRel φ3 φ1) :
|
||||
𝓣ᶠ([ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca) = 0 := by
|
||||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_singleton]
|
||||
rw [summerCommute_jacobi_ofCrAnList]
|
||||
simp [ofCrAnList_singleton]
|
||||
right
|
||||
rw [superCommute_ofCrAnState_ofCrAnState_symm φ1]
|
||||
simp
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h12 ]
|
||||
simp
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h13]
|
||||
simp
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel
|
||||
(φ1 φ2 φ3 : 𝓕.CrAnStates) (h : ¬ (
|
||||
crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
|
||||
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
|
||||
crAnTimeOrderRel φ3 φ1 ∧ crAnTimeOrderRel φ3 φ2)) :
|
||||
𝓣ᶠ([ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca) = 0 := by
|
||||
simp at h
|
||||
by_cases h23 : ¬ crAnTimeOrderRel φ2 φ3
|
||||
· simp_all
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h23]
|
||||
simp_all
|
||||
by_cases h32 : ¬ crAnTimeOrderRel φ3 φ2
|
||||
· simp_all
|
||||
rw [superCommute_ofCrAnState_ofCrAnState_symm]
|
||||
simp
|
||||
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h32]
|
||||
simp
|
||||
simp_all
|
||||
by_cases h12 : ¬ crAnTimeOrderRel φ1 φ2
|
||||
· have h13 : ¬ crAnTimeOrderRel φ1 φ3 := by
|
||||
intro h13
|
||||
apply h12
|
||||
exact IsTrans.trans φ1 φ3 φ2 h13 h32
|
||||
rw [timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel h12 h13]
|
||||
simp_all
|
||||
have h13 : crAnTimeOrderRel φ1 φ3 := IsTrans.trans φ1 φ2 φ3 h12 h23
|
||||
simp_all
|
||||
by_cases h21 : ¬ crAnTimeOrderRel φ2 φ1
|
||||
· simp_all
|
||||
have h31 : ¬ crAnTimeOrderRel φ3 φ1 := by
|
||||
intro h31
|
||||
apply h21
|
||||
exact IsTrans.trans φ2 φ3 φ1 h23 h31
|
||||
rw [timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel' h21 h31]
|
||||
simp_all
|
||||
refine False.elim (h ?_)
|
||||
exact IsTrans.trans φ3 φ2 φ1 h32 h21
|
||||
|
||||
|
||||
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_eq_time
|
||||
{φ ψ : 𝓕.CrAnStates} (h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) :
|
||||
𝓣ᶠ([ofCrAnState φ, ofCrAnState ψ]ₛca) = [ofCrAnState φ, ofCrAnState ψ]ₛca := by
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ lemma ι_superCommute_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
|
|||
left
|
||||
use φa, φa', hφa, hφa'
|
||||
|
||||
lemma ι_superCommute_of_diff_statistic (φ ψ : 𝓕.CrAnStates)
|
||||
lemma ι_superCommute_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
|
||||
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : ι [ofCrAnState φ, ofCrAnState ψ]ₛca = 0 := by
|
||||
apply ι_of_mem_fieldOpIdealSet
|
||||
simp only [fieldOpIdealSet, exists_prop, exists_and_left, Set.mem_setOf_eq]
|
||||
|
|
@ -107,7 +107,7 @@ lemma ι_superCommute_zero_of_fermionic (φ ψ : 𝓕.CrAnStates)
|
|||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton] at h ⊢
|
||||
rcases statistic_neq_of_superCommute_fermionic h with h | h
|
||||
· simp [ofCrAnList_singleton]
|
||||
apply ι_superCommute_of_diff_statistic _ _
|
||||
apply ι_superCommute_of_diff_statistic
|
||||
simpa using h
|
||||
· simp [h]
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,175 @@
|
|||
/-
|
||||
Copyright (c) 2025 Joseph Tooby-Smith. All rights reserved.
|
||||
Released under Apache 2.0 license as described in the file LICENSE.
|
||||
Authors: Joseph Tooby-Smith
|
||||
-/
|
||||
import HepLean.PerturbationTheory.Algebras.CrAnAlgebra.TimeOrder
|
||||
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.Basic
|
||||
/-!
|
||||
|
||||
# Time Ordering on Field operator algebra
|
||||
|
||||
-/
|
||||
|
||||
namespace FieldSpecification
|
||||
open CrAnAlgebra
|
||||
open HepLean.List
|
||||
open FieldStatistic
|
||||
|
||||
namespace FieldOpAlgebra
|
||||
variable {𝓕 : FieldSpecification}
|
||||
|
||||
lemma ι_timeOrder_superCommute_time {φ ψ : 𝓕.CrAnStates}
|
||||
(hφψ : crAnTimeOrderRel φ ψ) (hψφ : crAnTimeOrderRel ψ φ) (a b : 𝓕.CrAnAlgebra) :
|
||||
ι 𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) =
|
||||
ι ([ofCrAnState φ, ofCrAnState ψ]ₛca * 𝓣ᶠ(a * b)) := by
|
||||
let pb (b : 𝓕.CrAnAlgebra) (hc : b ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
|
||||
Prop := ι 𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) =
|
||||
ι ([ofCrAnState φ, ofCrAnState ψ]ₛca * 𝓣ᶠ(a * b))
|
||||
change pb b (Basis.mem_span _ b)
|
||||
apply Submodule.span_induction
|
||||
· intro x hx
|
||||
obtain ⟨φs, rfl⟩ := hx
|
||||
simp [pb]
|
||||
let pa (a : 𝓕.CrAnAlgebra) (hc : a ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
|
||||
Prop := ι 𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * ofCrAnList φs) =
|
||||
ι ([ofCrAnState φ, ofCrAnState ψ]ₛca * 𝓣ᶠ(a* ofCrAnList φs))
|
||||
change pa a (Basis.mem_span _ a)
|
||||
apply Submodule.span_induction
|
||||
· intro x hx
|
||||
obtain ⟨φs', rfl⟩ := hx
|
||||
simp [pa]
|
||||
conv_lhs =>
|
||||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
|
||||
simp [mul_sub, sub_mul, ← ofCrAnList_append]
|
||||
rw [timeOrder_ofCrAnList, timeOrder_ofCrAnList]
|
||||
have h1 : crAnTimeOrderSign (φs' ++ φ :: ψ :: φs) = crAnTimeOrderSign (φs' ++ ψ :: φ :: φs) := by
|
||||
trans crAnTimeOrderSign (φs' ++ [φ, ψ] ++ φs)
|
||||
simp
|
||||
rw [crAnTimeOrderSign]
|
||||
have hp : List.Perm [φ,ψ] [ψ,φ] := by exact List.Perm.swap ψ φ []
|
||||
rw [Wick.koszulSign_perm_eq _ _ φ _ _ _ _ _ hp]
|
||||
simp
|
||||
rfl
|
||||
simp_all
|
||||
rw [h1]
|
||||
simp
|
||||
have h1 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ φs' [φ, ψ] φs
|
||||
(by simp_all)
|
||||
rw [crAnTimeOrderList, show φs' ++ φ :: ψ :: φs = φs' ++ [φ, ψ] ++ φs by simp, h1]
|
||||
have h2 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ φs' [ψ, φ] φs
|
||||
(by simp_all)
|
||||
rw [crAnTimeOrderList, show φs' ++ ψ :: φ :: φs = φs' ++ [ψ, φ] ++ φs by simp, h2]
|
||||
repeat rw [ofCrAnList_append]
|
||||
rw [smul_smul, mul_comm, ← smul_smul, ← smul_sub]
|
||||
rw [map_mul, map_mul, map_mul, map_mul, map_mul, map_mul, map_mul, map_mul]
|
||||
rw [← mul_smul_comm]
|
||||
rw [mul_assoc, mul_assoc, mul_assoc ,mul_assoc ,mul_assoc ,mul_assoc]
|
||||
rw [← mul_sub, ← mul_sub, mul_smul_comm, mul_smul_comm, ← smul_mul_assoc,
|
||||
← smul_mul_assoc]
|
||||
rw [← sub_mul]
|
||||
have h1 : (ι (ofCrAnList [φ, ψ]) - (exchangeSign (𝓕.crAnStatistics φ)) (𝓕.crAnStatistics ψ) • ι (ofCrAnList [ψ, φ])) =
|
||||
ι [ofCrAnState φ, ofCrAnState ψ]ₛca := by
|
||||
rw [superCommute_ofCrAnState_ofCrAnState]
|
||||
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append]
|
||||
simp only [instCommGroup.eq_1, List.singleton_append, Algebra.smul_mul_assoc, map_sub,
|
||||
map_smul]
|
||||
rw [← ofCrAnList_append]
|
||||
simp
|
||||
rw [h1]
|
||||
have hc : ι ((superCommute (ofCrAnState φ)) (ofCrAnState ψ)) ∈ Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
|
||||
apply ι_superCommute_ofCrAnState_ofCrAnState_mem_center
|
||||
rw [Subalgebra.mem_center_iff] at hc
|
||||
repeat rw [← mul_assoc]
|
||||
rw [hc]
|
||||
repeat rw [mul_assoc]
|
||||
rw [smul_mul_assoc]
|
||||
rw [← map_mul, ← map_mul, ← map_mul, ← map_mul]
|
||||
rw [← ofCrAnList_append, ← ofCrAnList_append, ← ofCrAnList_append, ← ofCrAnList_append]
|
||||
have h1 := insertionSort_of_takeWhile_filter 𝓕.crAnTimeOrderRel φ φs' φs
|
||||
simp at h1 ⊢
|
||||
rw [← h1]
|
||||
rw [← crAnTimeOrderList]
|
||||
by_cases hq : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)
|
||||
· rw [ι_superCommute_of_diff_statistic hq]
|
||||
simp
|
||||
· rw [crAnTimeOrderSign, Wick.koszulSign_eq_rel_eq_stat _ _, ← crAnTimeOrderSign]
|
||||
rw [timeOrder_ofCrAnList]
|
||||
simp
|
||||
exact hψφ
|
||||
exact hφψ
|
||||
simpa using hq
|
||||
· simp [pa]
|
||||
· intro x y hx hy hpx hpy
|
||||
simp_all [pa,mul_add, add_mul]
|
||||
· intro x hx hpx
|
||||
simp_all [pa, hpx]
|
||||
· simp [pb]
|
||||
· intro x y hx hy hpx hpy
|
||||
simp_all [pb,mul_add, add_mul]
|
||||
· intro x hx hpx
|
||||
simp_all [pb, hpx]
|
||||
|
||||
/-!
|
||||
|
||||
## Defining normal order for `FiedOpAlgebra`.
|
||||
|
||||
-/
|
||||
|
||||
lemma ι_timeOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
|
||||
(h : a ∈ TwoSidedIdeal.span 𝓕.fieldOpIdealSet) : ι 𝓣ᶠ(a) = 0 := by
|
||||
rw [TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure] at h
|
||||
let p {k : Set 𝓕.CrAnAlgebra} (a : CrAnAlgebra 𝓕) (h : a ∈ AddSubgroup.closure k) := ι 𝓣ᶠ(a) = 0
|
||||
change p a h
|
||||
apply AddSubgroup.closure_induction
|
||||
· intro x hx
|
||||
obtain ⟨a, ha, b, hb, rfl⟩ := Set.mem_mul.mp hx
|
||||
obtain ⟨a, ha, c, hc, rfl⟩ := ha
|
||||
simp only [p]
|
||||
simp only [fieldOpIdealSet, exists_prop, exists_and_left, Set.mem_setOf_eq] at hc
|
||||
match hc with
|
||||
| Or.inl hc =>
|
||||
obtain ⟨φa, φa', hφa, hφa', rfl⟩ := hc
|
||||
sorry
|
||||
| Or.inr (Or.inl hc) =>
|
||||
obtain ⟨φa, φa', hφa, hφa', rfl⟩ := hc
|
||||
sorry
|
||||
| Or.inr (Or.inr (Or.inl hc)) =>
|
||||
obtain ⟨φa, φa', hφa, hφa', rfl⟩ := hc
|
||||
sorry
|
||||
| Or.inr (Or.inr (Or.inr hc)) =>
|
||||
obtain ⟨φa, φa', hφa, hφa', rfl⟩ := hc
|
||||
sorry
|
||||
· simp [p]
|
||||
· intro x y hx hy
|
||||
simp only [map_add, p]
|
||||
intro h1 h2
|
||||
simp [h1, h2]
|
||||
· intro x hx
|
||||
simp [p]
|
||||
|
||||
lemma ι_timeOrder_eq_of_equiv (a b : 𝓕.CrAnAlgebra) (h : a ≈ b) :
|
||||
ι 𝓣ᶠ(a) = ι 𝓣ᶠ(b) := by
|
||||
rw [equiv_iff_sub_mem_ideal] at h
|
||||
rw [LinearMap.sub_mem_ker_iff.mp]
|
||||
simp only [LinearMap.mem_ker, ← map_sub]
|
||||
exact ι_timeOrder_zero_of_mem_ideal (a - b) h
|
||||
|
||||
/-- Normal ordering on `FieldOpAlgebra`. -/
|
||||
noncomputable def timeOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where
|
||||
toFun := Quotient.lift (ι.toLinearMap ∘ₗ CrAnAlgebra.timeOrder) ι_timeOrder_eq_of_equiv
|
||||
map_add' x y := by
|
||||
obtain ⟨x, hx⟩ := ι_surjective x
|
||||
obtain ⟨y, hy⟩ := ι_surjective y
|
||||
subst hx hy
|
||||
rw [← map_add, ι_apply, ι_apply, ι_apply]
|
||||
rw [Quotient.lift_mk, Quotient.lift_mk, Quotient.lift_mk]
|
||||
simp
|
||||
map_smul' c y := by
|
||||
obtain ⟨y, hy⟩ := ι_surjective y
|
||||
subst hy
|
||||
rw [← map_smul, ι_apply, ι_apply]
|
||||
simp
|
||||
|
||||
end FieldOpAlgebra
|
||||
end FieldSpecification
|
||||
|
|
@ -235,6 +235,10 @@ lemma ofList_map_eq_finset_prod (s : 𝓕 → FieldStatistic) :
|
|||
simp only [List.length_cons, List.nodup_cons] at hl
|
||||
exact hl.2
|
||||
|
||||
lemma ofList_pair (s : 𝓕 → FieldStatistic) (φ1 φ2 : 𝓕) :
|
||||
ofList s [φ1, φ2] = s φ1 * s φ2 := by
|
||||
rw [ofList_cons_eq_mul, ofList_singleton]
|
||||
|
||||
/-!
|
||||
|
||||
## ofList and take
|
||||
|
|
|
|||
|
|
@ -280,6 +280,40 @@ lemma koszulSign_swap_eq_rel {ψ φ : 𝓕} (h1 : le φ ψ) (h2 : le ψ φ) : (
|
|||
apply Wick.koszulSignInsert_eq_perm
|
||||
exact List.Perm.append_left φs (List.Perm.swap ψ φ φs')
|
||||
|
||||
lemma koszulSign_eq_rel_eq_stat_append {ψ φ : 𝓕} [IsTrans 𝓕 le] [IsTotal 𝓕 le]
|
||||
(h1 : le φ ψ) (h2 : le ψ φ) (hq : q ψ = q φ) : (φs : List 𝓕) →
|
||||
koszulSign q le (φ :: ψ :: φs) = koszulSign q le φs := by
|
||||
intro φs
|
||||
simp [koszulSign, ← mul_assoc]
|
||||
trans 1 * koszulSign q le φs
|
||||
swap
|
||||
simp
|
||||
congr
|
||||
simp [koszulSignInsert]
|
||||
simp_all
|
||||
rw [koszulSignInsert_eq_rel_eq_stat q le h1 h2 hq]
|
||||
simp
|
||||
|
||||
lemma koszulSign_eq_rel_eq_stat {ψ φ : 𝓕} [IsTrans 𝓕 le] [IsTotal 𝓕 le]
|
||||
(h1 : le φ ψ) (h2 : le ψ φ) (hq : q ψ = q φ) : (φs' φs : List 𝓕) →
|
||||
koszulSign q le (φs' ++ φ :: ψ :: φs) = koszulSign q le (φs' ++ φs)
|
||||
| [], φs => by
|
||||
simp
|
||||
exact koszulSign_eq_rel_eq_stat_append q le h1 h2 hq φs
|
||||
| φ'' :: φs', φs => by
|
||||
simp [koszulSign]
|
||||
rw [koszulSign_eq_rel_eq_stat h1 h2 hq φs' φs]
|
||||
simp
|
||||
left
|
||||
trans koszulSignInsert q le φ'' (φ :: ψ :: (φs' ++ φs) )
|
||||
apply koszulSignInsert_eq_perm
|
||||
refine List.Perm.symm (List.perm_cons_append_cons φ ?_)
|
||||
exact List.Perm.symm List.perm_middle
|
||||
rw [koszulSignInsert_eq_remove_same_stat_append q le ]
|
||||
simp_all
|
||||
simp_all
|
||||
simp_all
|
||||
|
||||
lemma koszulSign_of_sorted : (φs : List 𝓕)
|
||||
→ (hs : List.Sorted le φs) → koszulSign q le φs = 1
|
||||
| [], _ => by
|
||||
|
|
@ -351,4 +385,53 @@ lemma koszulSign_of_append_eq_insertionSort [IsTotal 𝓕 le] [IsTrans 𝓕 le]
|
|||
refine List.Perm.append_left φs'' ?_
|
||||
exact List.Perm.symm (List.perm_insertionSort le φs)
|
||||
|
||||
/-!
|
||||
|
||||
# koszulSign with permutations
|
||||
|
||||
-/
|
||||
|
||||
lemma koszulSign_perm_eq_append [IsTotal 𝓕 le] [IsTrans 𝓕 le] (φ : 𝓕) ( φs φs' φs2 : List 𝓕)
|
||||
(hp : φs.Perm φs') : (h : ∀ φ' ∈ φs, le φ φ' ∧ le φ' φ) →
|
||||
koszulSign q le (φs ++ φs2) = koszulSign q le (φs' ++ φs2) := by
|
||||
let motive (φs φs' : List 𝓕) (hp : φs.Perm φs') : Prop :=
|
||||
(h : ∀ φ' ∈ φs, le φ φ' ∧ le φ' φ) →
|
||||
koszulSign q le (φs ++ φs2) = koszulSign q le (φs' ++ φs2)
|
||||
change motive φs φs' hp
|
||||
apply List.Perm.recOn
|
||||
· simp [motive]
|
||||
· intro x l1 l2 h ih hxφ
|
||||
simp_all [motive]
|
||||
simp [koszulSign, ih]
|
||||
left
|
||||
apply koszulSignInsert_eq_perm
|
||||
exact (List.perm_append_right_iff φs2).mpr h
|
||||
· intro x y l h
|
||||
simp_all [motive]
|
||||
apply Wick.koszulSign_swap_eq_rel_cons
|
||||
exact IsTrans.trans y φ x h.1.2 h.2.1.1
|
||||
exact IsTrans.trans x φ y h.2.1.2 h.1.1
|
||||
· intro l1 l2 l3 h1 h2 ih1 ih2 h
|
||||
simp_all [motive]
|
||||
refine (ih2 ?_)
|
||||
intro φ' hφ
|
||||
refine h φ' ?_
|
||||
exact (List.Perm.mem_iff (id (List.Perm.symm h1))).mp hφ
|
||||
|
||||
lemma koszulSign_perm_eq [IsTotal 𝓕 le] [IsTrans 𝓕 le] (φ : 𝓕) : (φs1 φs φs' φs2 : List 𝓕) →
|
||||
(h : ∀ φ' ∈ φs, le φ φ' ∧ le φ' φ) → (hp : φs.Perm φs') →
|
||||
koszulSign q le (φs1 ++ φs ++ φs2) = koszulSign q le (φs1 ++ φs' ++ φs2)
|
||||
| [], φs, φs', φs2, h, hp => by
|
||||
simp
|
||||
exact koszulSign_perm_eq_append q le φ φs φs' φs2 hp h
|
||||
| φ1 :: φs1, φs, φs', φs2, h, hp => by
|
||||
simp only [koszulSign, List.append_eq]
|
||||
have ih := koszulSign_perm_eq φ φs1 φs φs' φs2 h hp
|
||||
rw [ih]
|
||||
congr 1
|
||||
apply koszulSignInsert_eq_perm
|
||||
refine (List.perm_append_right_iff φs2).mpr ?_
|
||||
exact List.Perm.append_left φs1 hp
|
||||
|
||||
|
||||
end Wick
|
||||
|
|
|
|||
|
|
@ -248,4 +248,42 @@ lemma koszulSignInsert_of_le_mem (φ0 : 𝓕) : (φs : List 𝓕) → (h : ∀
|
|||
· exact h φ1 (List.mem_cons_self _ _)
|
||||
|
||||
|
||||
lemma koszulSignInsert_eq_rel_eq_stat {ψ φ : 𝓕} [IsTotal 𝓕 le] [IsTrans 𝓕 le]
|
||||
(h1 : le φ ψ) (h2 : le ψ φ) (hq : q ψ = q φ) : (φs : List 𝓕) →
|
||||
koszulSignInsert q le φ φs = koszulSignInsert q le ψ φs
|
||||
| [] => by
|
||||
simp [koszulSignInsert]
|
||||
| φ' :: φs => by
|
||||
simp [koszulSignInsert]
|
||||
simp_all
|
||||
by_cases hr : le φ φ'
|
||||
· simp [hr]
|
||||
have h1' : le ψ φ' := by
|
||||
apply IsTrans.trans ψ φ φ' h2 hr
|
||||
simp [h1']
|
||||
exact koszulSignInsert_eq_rel_eq_stat h1 h2 hq φs
|
||||
· have hψφ' : ¬ le ψ φ' := by
|
||||
intro hψφ'
|
||||
apply hr
|
||||
apply IsTrans.trans φ ψ φ' h1 hψφ'
|
||||
simp [hr, hψφ']
|
||||
rw [koszulSignInsert_eq_rel_eq_stat h1 h2 hq φs]
|
||||
|
||||
lemma koszulSignInsert_eq_remove_same_stat_append {ψ φ φ' : 𝓕} [IsTotal 𝓕 le] [IsTrans 𝓕 le]
|
||||
(h1 : le φ ψ) (h2 : le ψ φ) (hq : q ψ = q φ) : ( φs : List 𝓕) →
|
||||
koszulSignInsert q le φ' (φ :: ψ :: φs) = koszulSignInsert q le φ' φs := by
|
||||
intro φs
|
||||
simp_all [koszulSignInsert]
|
||||
by_cases hφ'φ : le φ' φ
|
||||
· have hφ'ψ : le φ' ψ := by
|
||||
apply IsTrans.trans φ' φ ψ hφ'φ h1
|
||||
simp [hφ'φ, hφ'ψ]
|
||||
· have hφ'ψ : ¬ le φ' ψ := by
|
||||
intro hφ'ψ
|
||||
apply hφ'φ
|
||||
apply IsTrans.trans φ' ψ φ hφ'ψ h2
|
||||
simp_all [hφ'φ, hφ'ψ]
|
||||
|
||||
|
||||
|
||||
end Wick
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue