feat: KoszulSign partial sort
This commit is contained in:
jstoobysmith
parent
48b0a60f34
commit
a79d0f8fed
6 changed files with 401 additions and 21 deletions
|
|
@ -118,6 +118,13 @@ lemma insertIdx_eraseIdx_fin {I : Type} :
|
|||
List.insertIdx_succ_cons, List.cons.injEq, true_and]
|
||||
exact insertIdx_eraseIdx_fin as ⟨n, Nat.lt_of_succ_lt_succ h⟩
|
||||
|
||||
lemma insertIdx_length_fst_append {I : Type} (φ : I) : (φs φs' : List I) →
|
||||
List.insertIdx φs.length φ (φs ++ φs') = (φs ++ φ :: φs')
|
||||
| [], φs' => by simp
|
||||
| φ' :: φs, φs' => by
|
||||
simp
|
||||
exact insertIdx_length_fst_append φ φs φs'
|
||||
|
||||
lemma get_eq_insertIdx_succAbove {I : Type} (i : I) (r : List I) (k : Fin r.length.succ) :
|
||||
r.get = (List.insertIdx k i r).get ∘
|
||||
(finCongr (insertIdx_length_fin i r k).symm) ∘ k.succAbove := by
|
||||
|
|
|
|||
|
|
@ -91,4 +91,290 @@ lemma insertionSortMin_lt_mem_insertionSortDropMinPos_of_lt {α : Type} (r : α
|
|||
simp only [hl, Nat.succ_eq_add_one, Fin.val_eq_val, ne_eq]
|
||||
exact Fin.succAbove_ne (insertionSortMinPosFin r a l) i
|
||||
|
||||
lemma insertionSort_insertionSort {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (l1 : List α):
|
||||
List.insertionSort r (List.insertionSort r l1) = List.insertionSort r l1 := by
|
||||
apply List.Sorted.insertionSort_eq
|
||||
exact List.sorted_insertionSort r l1
|
||||
|
||||
lemma orderedInsert_commute {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a b : α) (hr : ¬ r a b) : (l : List α) →
|
||||
List.orderedInsert r a (List.orderedInsert r b l) = List.orderedInsert r b (List.orderedInsert r a l)
|
||||
| [] => by
|
||||
have hrb : r b a := by
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
simp [hr, hrb]
|
||||
| c :: l => by
|
||||
have hrb : r b a := by
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
simp
|
||||
by_cases h : r a c
|
||||
· simp [h, hrb]
|
||||
rw [if_pos]
|
||||
simp [hrb, hr, h]
|
||||
exact IsTrans.trans (r :=r) _ _ _ hrb h
|
||||
· simp [h]
|
||||
have hrca : r c a := by
|
||||
have ht := IsTotal.total (r := r) a c
|
||||
simp_all
|
||||
by_cases hbc : r b c
|
||||
· simp [hbc, hr, h]
|
||||
· simp [hbc, h]
|
||||
exact orderedInsert_commute r a b hr l
|
||||
|
||||
lemma insertionSort_orderedInsert_append {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) : (l1 l2 : List α) →
|
||||
List.insertionSort r (List.orderedInsert r a l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2)
|
||||
| [], l2 => by
|
||||
simp
|
||||
| b :: l1, l2 => by
|
||||
conv_lhs => simp
|
||||
by_cases h : r a b
|
||||
· simp [h]
|
||||
conv_lhs => simp [h]
|
||||
rw [insertionSort_orderedInsert_append r a l1 l2]
|
||||
simp
|
||||
rw [orderedInsert_commute r a b h]
|
||||
|
||||
|
||||
lemma insertionSort_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] : (l1 l2 : List α) →
|
||||
List.insertionSort r (List.insertionSort r l1 ++ l2) = List.insertionSort r (l1 ++ l2)
|
||||
| [], l2 => by
|
||||
simp
|
||||
| a :: l1, l2 => by
|
||||
conv_lhs => simp
|
||||
rw [insertionSort_orderedInsert_append]
|
||||
simp
|
||||
rw [insertionSort_insertionSort_append r l1 l2]
|
||||
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsert_length {α : Type} (r : α → α → Prop) [DecidableRel r] (a : α) (l : List α) :
|
||||
(List.orderedInsert r a l).length = (a :: l).length := by
|
||||
apply List.Perm.length_eq
|
||||
exact List.perm_orderedInsert r a l
|
||||
|
||||
lemma takeWhile_orderedInsert {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r]
|
||||
(a b : α) (hr : ¬ r a b) : (l : List α) →
|
||||
(List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b l)).length =
|
||||
(List.takeWhile (fun c => !decide (r a c)) l).length + 1
|
||||
| [] => by
|
||||
simp [hr]
|
||||
| c :: l => by
|
||||
simp
|
||||
by_cases h : r b c
|
||||
· simp [h]
|
||||
rw [List.takeWhile_cons_of_pos]
|
||||
simp
|
||||
simp [hr]
|
||||
· simp [h]
|
||||
have hrba : r b a:= by
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
have hl : ¬ r a c := by
|
||||
by_contra hn
|
||||
apply h
|
||||
exact IsTrans.trans _ _ _ hrba hn
|
||||
simp [hl]
|
||||
exact takeWhile_orderedInsert r a b hr l
|
||||
|
||||
lemma takeWhile_orderedInsert' {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r]
|
||||
(a b : α) (hr : ¬ r a b) : (l : List α) →
|
||||
(List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a l)).length =
|
||||
(List.takeWhile (fun c => !decide (r b c)) l).length
|
||||
| [] => by
|
||||
simp
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
| c :: l => by
|
||||
have hrba : r b a:= by
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
simp
|
||||
by_cases h : r b c
|
||||
· simp [h, hrba]
|
||||
by_cases hac : r a c
|
||||
· simp [hac, hrba]
|
||||
· simp [hac, h]
|
||||
· have hcb : r c b := by
|
||||
have ht := IsTotal.total (r := r) b c
|
||||
simp_all
|
||||
by_cases hac : r a c
|
||||
· refine False.elim (h ?_)
|
||||
exact IsTrans.trans _ _ _ hrba hac
|
||||
· 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) →
|
||||
insertionSortEquiv r (a :: b :: l) ⟨n + 2, hn⟩ = (finCongr (by simp))
|
||||
(insertionSortEquiv r (b :: a :: l) ⟨n + 2, hn⟩):= by
|
||||
have hrba : r b a:= by
|
||||
have ht := IsTotal.total (r := r) a b
|
||||
simp_all
|
||||
intro l hn
|
||||
simp [insertionSortEquiv]
|
||||
conv_lhs => erw [equivCons_succ]
|
||||
conv_rhs => erw [equivCons_succ]
|
||||
simp
|
||||
conv_lhs =>
|
||||
rhs
|
||||
rhs
|
||||
erw [orderedInsertEquiv_succ]
|
||||
conv_lhs => erw [orderedInsertEquiv_fin_succ]
|
||||
simp
|
||||
conv_rhs =>
|
||||
rhs
|
||||
rhs
|
||||
erw [orderedInsertEquiv_succ]
|
||||
conv_rhs => erw [orderedInsertEquiv_fin_succ]
|
||||
ext
|
||||
simp
|
||||
let a1 : Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), orderedInsertPos_lt_length r (List.orderedInsert r b (List.insertionSort r l)) a⟩
|
||||
let b1 : Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), orderedInsertPos_lt_length r (List.insertionSort r l) b⟩
|
||||
let a2 : Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), orderedInsertPos_lt_length r (List.insertionSort r l) a⟩
|
||||
let b2 : Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), orderedInsertPos_lt_length r (List.orderedInsert r a (List.insertionSort r l)) b⟩
|
||||
have ht : (List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l))
|
||||
= (List.takeWhile (fun c => !decide (r b c)) ((List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l)))) := by
|
||||
rw [List.takeWhile_takeWhile]
|
||||
simp
|
||||
congr
|
||||
funext c
|
||||
simp
|
||||
intro hbc hac
|
||||
refine hbc ?_
|
||||
exact IsTrans.trans _ _ _ hrba hac
|
||||
have ha1 : b1.1 ≤ a2.1 := by
|
||||
simp [a1, a2, orderedInsertPos]
|
||||
rw [ht]
|
||||
apply List.Sublist.length_le
|
||||
exact List.takeWhile_sublist fun c => !decide (r b c)
|
||||
have ha2 : a1.1 = a2.1 + 1 := by
|
||||
simp [a1, a2, orderedInsertPos]
|
||||
rw [takeWhile_orderedInsert]
|
||||
exact hr
|
||||
have hb : b1.1 = b2.1 := by
|
||||
simp [b1, b2, orderedInsertPos]
|
||||
rw [takeWhile_orderedInsert']
|
||||
exact hr
|
||||
let n := ((insertionSortEquiv r l) ⟨n, by simpa using hn⟩)
|
||||
change (a1.succAbove ⟨b1.succAbove n, _⟩).1 = (b2.succAbove ⟨a2.succAbove n, _⟩).1
|
||||
trans if (b1.succAbove n).1 < a1.1 then (b1.succAbove n).1 else (b1.succAbove n).1 + 1
|
||||
· rw [Fin.succAbove]
|
||||
simp only [Fin.castSucc_mk, Fin.lt_def, Fin.succ_mk]
|
||||
by_cases ha : (b1.succAbove n).1 < a1.1
|
||||
· simp [ha]
|
||||
· simp [ha]
|
||||
trans if (a2.succAbove n).1 < b2.1 then (a2.succAbove n).1 else (a2.succAbove n).1 + 1
|
||||
swap
|
||||
· conv_rhs => rw [Fin.succAbove]
|
||||
simp only [Fin.castSucc_mk, Fin.lt_def, Fin.succ_mk]
|
||||
by_cases ha : (a2.succAbove n).1 < b2.1
|
||||
· simp [ha]
|
||||
· simp [ha]
|
||||
have hbs1 : (b1.succAbove n).1 = if n.1 < b1.1 then n.1 else n.1 + 1 := by
|
||||
rw [Fin.succAbove]
|
||||
simp only [Fin.castSucc_mk, Fin.lt_def, Fin.succ_mk]
|
||||
by_cases ha : n.1 < b1.1
|
||||
· simp [ha]
|
||||
· simp [ha]
|
||||
have has2 : (a2.succAbove n).1 = if n.1 < a2.1 then n.1 else n.1 + 1 := by
|
||||
rw [Fin.succAbove]
|
||||
simp only [Fin.castSucc_mk, Fin.lt_def, Fin.succ_mk]
|
||||
by_cases ha : n.1 < a2.1
|
||||
· simp [ha]
|
||||
· simp [ha]
|
||||
rw [hbs1, has2, hb, ha2]
|
||||
have hnat (a2 b2 n : ℕ) (h : b2 ≤ a2) : (if (if ↑n < ↑b2 then ↑n else ↑n + 1) < ↑a2 + 1 then if ↑n < ↑b2 then ↑n else ↑n + 1
|
||||
else (if ↑n < ↑b2 then ↑n else ↑n + 1) + 1) =
|
||||
if (if ↑n < ↑a2 then ↑n else ↑n + 1) < ↑b2 then if ↑n < ↑a2 then ↑n else ↑n + 1
|
||||
else (if ↑n < ↑a2 then ↑n else ↑n + 1) + 1 := by
|
||||
by_cases hnb2 : n < b2
|
||||
· simp [hnb2]
|
||||
have h1 : n < a2 + 1 := by omega
|
||||
have h2 : n < a2 := by omega
|
||||
simp [h1, h2, hnb2]
|
||||
· simp [hnb2]
|
||||
by_cases ha2 : n < a2
|
||||
· simp [ha2, hnb2]
|
||||
· simp [ha2]
|
||||
rw [if_neg]
|
||||
omega
|
||||
apply hnat
|
||||
rw [← hb]
|
||||
exact ha1
|
||||
|
||||
|
||||
|
||||
lemma insertionSortEquiv_orderedInsert_append {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a a2 : α) : (l1 l2 : List α) →
|
||||
(insertionSortEquiv r (List.orderedInsert r a l1 ++ a2 :: l2) ⟨l1.length + 1, by
|
||||
simp⟩)
|
||||
= (finCongr (by simp; omega))
|
||||
((insertionSortEquiv r ( a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, by simp⟩)
|
||||
| [], l2 => by
|
||||
simp
|
||||
| b :: l1, l2 => by
|
||||
by_cases h : r a b
|
||||
· have h1 : (List.orderedInsert r a (b :: l1) ++ a2 :: l2) = (a :: b :: l1 ++ a2 :: l2) := by
|
||||
simp [h]
|
||||
rw [insertionSortEquiv_congr _ _ h1]
|
||||
simp
|
||||
· have h1 : (List.orderedInsert r a (b :: l1) ++ a2 :: l2) = (b :: List.orderedInsert r a (l1) ++ a2 :: l2) := by
|
||||
simp [h]
|
||||
rw [insertionSortEquiv_congr _ _ h1]
|
||||
simp
|
||||
conv_lhs => simp [insertionSortEquiv]
|
||||
rw [insertionSortEquiv_orderedInsert_append r a]
|
||||
have hl : (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) =
|
||||
List.insertionSort r (a :: l1 ++ a2 :: l2) := by
|
||||
exact insertionSort_orderedInsert_append r a l1 (a2 :: l2)
|
||||
rw [orderedInsertEquiv_congr _ _ _ hl]
|
||||
simp
|
||||
change Fin.cast _ ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, by simp⟩) = _
|
||||
have hl : l1.length + 1 +1 = l1.length + 2 := by omega
|
||||
simp [hl]
|
||||
conv_rhs =>
|
||||
erw [insertionSortEquiv_commute _ _ _ h _ _]
|
||||
simp
|
||||
|
||||
|
||||
|
||||
|
||||
lemma insertionSortEquiv_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
|
||||
[IsTotal α r] [IsTrans α r] (a : α) : (l1 l2 : List α) →
|
||||
(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2) ⟨l1.length, by simp⟩)
|
||||
= finCongr (by simp) (insertionSortEquiv r (l1 ++ a :: l2) ⟨l1.length, by simp⟩)
|
||||
| [], l2 => by
|
||||
simp
|
||||
| b :: l1, l2 => by
|
||||
simp
|
||||
have hl := insertionSortEquiv_orderedInsert_append r b a (List.insertionSort r l1) l2
|
||||
simp at hl
|
||||
rw [hl]
|
||||
have ih := insertionSortEquiv_insertionSort_append r a l1 l2
|
||||
simp [insertionSortEquiv]
|
||||
rw [ih]
|
||||
have hl : (List.insertionSort r (List.insertionSort r l1 ++ a :: l2)) = (List.insertionSort r (l1 ++ a :: l2)) := by
|
||||
exact insertionSort_insertionSort_append r l1 (a :: l2)
|
||||
rw [orderedInsertEquiv_congr _ _ _ hl]
|
||||
simp
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
end HepLean.List
|
||||
|
|
|
|||
|
|
@ -14,7 +14,6 @@ import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.Basic
|
|||
namespace FieldSpecification
|
||||
open CrAnAlgebra
|
||||
open HepLean.List
|
||||
open WickContraction
|
||||
open FieldStatistic
|
||||
|
||||
namespace FieldOpAlgebra
|
||||
|
|
|
|||
|
|
@ -234,27 +234,10 @@ lemma crAnTimeOrderSign_pair_not_ordered {φ ψ : 𝓕.CrAnStates} (h : ¬ crAnT
|
|||
rw [if_neg h]
|
||||
simp [FieldStatistic.exchangeSign_eq_if]
|
||||
|
||||
lemma crAnTimeOrderSign_swap_eq_time_cons {φ ψ : 𝓕.CrAnStates}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs' : List 𝓕.CrAnStates) :
|
||||
crAnTimeOrderSign (φ :: ψ :: φs') = crAnTimeOrderSign (ψ :: φ :: φs') := by
|
||||
simp only [crAnTimeOrderSign, Wick.koszulSign, ← mul_assoc, mul_eq_mul_right_iff]
|
||||
left
|
||||
rw [mul_comm]
|
||||
simp [Wick.koszulSignInsert, h1, h2]
|
||||
|
||||
lemma crAnTimeOrderSign_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) : (φs φs' : List 𝓕.CrAnStates) →
|
||||
crAnTimeOrderSign (φs ++ φ :: ψ :: φs') = crAnTimeOrderSign (φs ++ ψ :: φ :: φs')
|
||||
| [], φs' => by
|
||||
simp only [crAnTimeOrderSign, List.nil_append]
|
||||
exact crAnTimeOrderSign_swap_eq_time_cons h1 h2 φs'
|
||||
| φ'' :: φs, φs' => by
|
||||
simp only [crAnTimeOrderSign, Wick.koszulSign, List.append_eq]
|
||||
rw [← crAnTimeOrderSign, ← crAnTimeOrderSign]
|
||||
rw [crAnTimeOrderSign_swap_eq_time h1 h2]
|
||||
congr 1
|
||||
apply Wick.koszulSignInsert_eq_perm
|
||||
exact List.Perm.append_left φs (List.Perm.swap ψ φ φs')
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs φs' : List 𝓕.CrAnStates) :
|
||||
crAnTimeOrderSign (φs ++ φ :: ψ :: φs') = crAnTimeOrderSign (φs ++ ψ :: φ :: φs') := by
|
||||
exact Wick.koszulSign_swap_eq_rel _ _ h1 h2 _ _
|
||||
|
||||
/-- Sort a list of `CrAnStates` based on `crAnTimeOrderRel`. -/
|
||||
def crAnTimeOrderList (φs : List 𝓕.CrAnStates) : List 𝓕.CrAnStates :=
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
|
|||
Authors: Joseph Tooby-Smith
|
||||
-/
|
||||
import HepLean.PerturbationTheory.Koszul.KoszulSignInsert
|
||||
import HepLean.Mathematics.List.InsertionSort
|
||||
/-!
|
||||
|
||||
# Koszul sign
|
||||
|
|
@ -259,4 +260,95 @@ lemma koszulSign_eraseIdx_insertionSortMinPos [IsTotal 𝓕 le] [IsTrans 𝓕 le
|
|||
apply Or.inl
|
||||
rfl
|
||||
|
||||
lemma koszulSign_swap_eq_rel_cons {ψ φ : 𝓕}
|
||||
(h1 : le φ ψ) (h2 : le ψ φ) (φs' : List 𝓕):
|
||||
koszulSign q le (φ :: ψ :: φs') = koszulSign q le (ψ :: φ :: φs') := by
|
||||
simp only [Wick.koszulSign, ← mul_assoc, mul_eq_mul_right_iff]
|
||||
left
|
||||
rw [mul_comm]
|
||||
simp [Wick.koszulSignInsert, h1, h2]
|
||||
|
||||
lemma koszulSign_swap_eq_rel {ψ φ : 𝓕} (h1 : le φ ψ) (h2 : le ψ φ) : (φs φs' : List 𝓕) →
|
||||
koszulSign q le (φs ++ φ :: ψ :: φs') = koszulSign q le (φs ++ ψ :: φ :: φs')
|
||||
| [], φs' => by
|
||||
simp only [List.nil_append]
|
||||
exact koszulSign_swap_eq_rel_cons q le h1 h2 φs'
|
||||
| φ'' :: φs, φs' => by
|
||||
simp only [Wick.koszulSign, List.append_eq]
|
||||
rw [koszulSign_swap_eq_rel h1 h2]
|
||||
congr 1
|
||||
apply Wick.koszulSignInsert_eq_perm
|
||||
exact List.Perm.append_left φs (List.Perm.swap ψ φ φs')
|
||||
|
||||
lemma koszulSign_of_sorted : (φs : List 𝓕)
|
||||
→ (hs : List.Sorted le φs) → koszulSign q le φs = 1
|
||||
| [], _ => by
|
||||
simp [koszulSign]
|
||||
| φ :: φs, h => by
|
||||
simp [koszulSign]
|
||||
simp at h
|
||||
rw [koszulSign_of_sorted φs h.2]
|
||||
simp
|
||||
exact koszulSignInsert_of_le_mem _ _ _ _ h.1
|
||||
|
||||
@[simp]
|
||||
lemma koszulSign_of_insertionSort [IsTotal 𝓕 le] [IsTrans 𝓕 le] (φs : List 𝓕) :
|
||||
koszulSign q le (List.insertionSort le φs) = 1 := by
|
||||
apply koszulSign_of_sorted
|
||||
exact List.sorted_insertionSort le φs
|
||||
|
||||
lemma koszulSign_of_append_eq_insertionSort_left [IsTotal 𝓕 le] [IsTrans 𝓕 le] : (φs φs' : List 𝓕) →
|
||||
koszulSign q le (φs ++ φs') =
|
||||
koszulSign q le (List.insertionSort le φs ++ φs') * koszulSign q le φs
|
||||
| φs, [] => by
|
||||
simp
|
||||
| φs, φ :: φs' => by
|
||||
have h1 : (φs ++ φ :: φs') = List.insertIdx φs.length φ (φs ++ φs') := by
|
||||
rw [insertIdx_length_fst_append]
|
||||
have h2 : (List.insertionSort le φs ++ φ :: φs') = List.insertIdx (List.insertionSort le φs).length φ (List.insertionSort le φs ++ φs') := by
|
||||
rw [insertIdx_length_fst_append]
|
||||
rw [h1, h2]
|
||||
rw [koszulSign_insertIdx]
|
||||
simp
|
||||
rw [koszulSign_insertIdx]
|
||||
simp [mul_assoc]
|
||||
left
|
||||
rw [koszulSign_of_append_eq_insertionSort_left φs φs']
|
||||
simp [mul_assoc]
|
||||
left
|
||||
simp [mul_comm]
|
||||
left
|
||||
congr 3
|
||||
· have h2 : (List.insertionSort le φs ++ φ :: φs') = List.insertIdx φs.length φ (List.insertionSort le φs ++ φs') := by
|
||||
rw [← insertIdx_length_fst_append]
|
||||
simp
|
||||
rw [insertionSortEquiv_congr _ _ h2.symm]
|
||||
simp
|
||||
rw [insertionSortEquiv_insertionSort_append]
|
||||
simp
|
||||
rw [insertionSortEquiv_congr _ _ h1.symm]
|
||||
simp
|
||||
· rw [insertIdx_length_fst_append]
|
||||
rw [show φs.length = (List.insertionSort le φs).length by simp]
|
||||
rw [insertIdx_length_fst_append]
|
||||
symm
|
||||
apply insertionSort_insertionSort_append
|
||||
· simp
|
||||
· simp
|
||||
|
||||
lemma koszulSign_of_append_eq_insertionSort [IsTotal 𝓕 le] [IsTrans 𝓕 le] : (φs'' φs φs' : List 𝓕) →
|
||||
koszulSign q le (φs'' ++ φs ++ φs') =
|
||||
koszulSign q le (φs'' ++ List.insertionSort le φs ++ φs') * koszulSign q le φs
|
||||
| [], φs, φs'=> by
|
||||
simp
|
||||
exact koszulSign_of_append_eq_insertionSort_left q le φs φs'
|
||||
| φ'' :: φs'', φs, φs' => by
|
||||
simp only [koszulSign, List.append_eq]
|
||||
rw [koszulSign_of_append_eq_insertionSort φs'' φs φs', ← mul_assoc]
|
||||
congr 2
|
||||
apply koszulSignInsert_eq_perm
|
||||
refine (List.perm_append_right_iff φs').mpr ?_
|
||||
refine List.Perm.append_left φs'' ?_
|
||||
exact List.Perm.symm (List.perm_insertionSort le φs)
|
||||
|
||||
end Wick
|
||||
|
|
|
|||
|
|
@ -235,4 +235,17 @@ lemma koszulSignInsert_cons (r0 r1 : 𝓕) (r : List 𝓕) :
|
|||
koszulSignInsert q le r0 r := by
|
||||
simp [koszulSignInsert, koszulSignCons]
|
||||
|
||||
lemma koszulSignInsert_of_le_mem (φ0 : 𝓕) : (φs : List 𝓕) → (h : ∀ b ∈ φs, le φ0 b) →
|
||||
koszulSignInsert q le φ0 φs = 1
|
||||
| [], _ => by
|
||||
simp [koszulSignInsert]
|
||||
| φ1 :: φs, h => by
|
||||
simp [koszulSignInsert]
|
||||
rw [if_pos]
|
||||
· apply koszulSignInsert_of_le_mem
|
||||
· intro b hb
|
||||
exact h b (List.mem_cons_of_mem _ hb)
|
||||
· exact h φ1 (List.mem_cons_self _ _)
|
||||
|
||||
|
||||
end Wick
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue