refactor: Rename States to FieldOps
This commit is contained in:
jstoobysmith
parent
171e80fc04
commit
8f41de5785
36 changed files with 946 additions and 946 deletions
|
|
@ -23,28 +23,28 @@ variable {𝓕 : FieldSpecification}
|
|||
/-- The time ordering relation on states. We have that `timeOrderRel φ0 φ1` is true
|
||||
if and only if `φ1` has a time less-then or equal to `φ0`, or `φ1` is a negative
|
||||
asymptotic state, or `φ0` is a positive asymptotic state. -/
|
||||
def timeOrderRel : 𝓕.States → 𝓕.States → Prop
|
||||
| States.outAsymp _, _ => True
|
||||
| States.position φ0, States.position φ1 => φ1.2 0 ≤ φ0.2 0
|
||||
| States.position _, States.inAsymp _ => True
|
||||
| States.position _, States.outAsymp _ => False
|
||||
| States.inAsymp _, States.outAsymp _ => False
|
||||
| States.inAsymp _, States.position _ => False
|
||||
| States.inAsymp _, States.inAsymp _ => True
|
||||
def timeOrderRel : 𝓕.FieldOp → 𝓕.FieldOp → Prop
|
||||
| FieldOp.outAsymp _, _ => True
|
||||
| FieldOp.position φ0, FieldOp.position φ1 => φ1.2 0 ≤ φ0.2 0
|
||||
| FieldOp.position _, FieldOp.inAsymp _ => True
|
||||
| FieldOp.position _, FieldOp.outAsymp _ => False
|
||||
| FieldOp.inAsymp _, FieldOp.outAsymp _ => False
|
||||
| FieldOp.inAsymp _, FieldOp.position _ => False
|
||||
| FieldOp.inAsymp _, FieldOp.inAsymp _ => True
|
||||
|
||||
/-- The relation `timeOrderRel` is decidable, but not computablly so due to
|
||||
`Real.decidableLE`. -/
|
||||
noncomputable instance : (φ φ' : 𝓕.States) → Decidable (timeOrderRel φ φ')
|
||||
| States.outAsymp _, _ => isTrue True.intro
|
||||
| States.position φ0, States.position φ1 => inferInstanceAs (Decidable (φ1.2 0 ≤ φ0.2 0))
|
||||
| States.position _, States.inAsymp _ => isTrue True.intro
|
||||
| States.position _, States.outAsymp _ => isFalse (fun a => a)
|
||||
| States.inAsymp _, States.outAsymp _ => isFalse (fun a => a)
|
||||
| States.inAsymp _, States.position _ => isFalse (fun a => a)
|
||||
| States.inAsymp _, States.inAsymp _ => isTrue True.intro
|
||||
noncomputable instance : (φ φ' : 𝓕.FieldOp) → Decidable (timeOrderRel φ φ')
|
||||
| FieldOp.outAsymp _, _ => isTrue True.intro
|
||||
| FieldOp.position φ0, FieldOp.position φ1 => inferInstanceAs (Decidable (φ1.2 0 ≤ φ0.2 0))
|
||||
| FieldOp.position _, FieldOp.inAsymp _ => isTrue True.intro
|
||||
| FieldOp.position _, FieldOp.outAsymp _ => isFalse (fun a => a)
|
||||
| FieldOp.inAsymp _, FieldOp.outAsymp _ => isFalse (fun a => a)
|
||||
| FieldOp.inAsymp _, FieldOp.position _ => isFalse (fun a => a)
|
||||
| FieldOp.inAsymp _, FieldOp.inAsymp _ => isTrue True.intro
|
||||
|
||||
/-- Time ordering is total. -/
|
||||
instance : IsTotal 𝓕.States 𝓕.timeOrderRel where
|
||||
instance : IsTotal 𝓕.FieldOp 𝓕.timeOrderRel where
|
||||
total a b := by
|
||||
cases a <;> cases b <;>
|
||||
simp only [or_self, or_false, or_true, timeOrderRel, Fin.isValue, implies_true, imp_self,
|
||||
|
|
@ -52,7 +52,7 @@ instance : IsTotal 𝓕.States 𝓕.timeOrderRel where
|
|||
exact LinearOrder.le_total _ _
|
||||
|
||||
/-- Time ordering is transitive. -/
|
||||
instance : IsTrans 𝓕.States 𝓕.timeOrderRel where
|
||||
instance : IsTrans 𝓕.FieldOp 𝓕.timeOrderRel where
|
||||
trans a b c := by
|
||||
cases a <;> cases b <;> cases c <;>
|
||||
simp only [timeOrderRel, Fin.isValue, implies_true, imp_self, IsEmpty.forall_iff]
|
||||
|
|
@ -68,10 +68,10 @@ open HepLean.List
|
|||
- for the list `[φ1(t = 4), φ2(t = 5), φ3(t = 3), φ4(t = 5)]` this would return `1`.
|
||||
This is defined for a list `φ :: φs` instead of `φs` to ensure that such a position exists.
|
||||
-/
|
||||
def maxTimeFieldPos (φ : 𝓕.States) (φs : List 𝓕.States) : ℕ :=
|
||||
def maxTimeFieldPos (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : ℕ :=
|
||||
insertionSortMinPos timeOrderRel φ φs
|
||||
|
||||
lemma maxTimeFieldPos_lt_length (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
lemma maxTimeFieldPos_lt_length (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
maxTimeFieldPos φ φs < (φ :: φs).length := by
|
||||
simp [maxTimeFieldPos]
|
||||
|
||||
|
|
@ -80,7 +80,7 @@ lemma maxTimeFieldPos_lt_length (φ : 𝓕.States) (φs : List 𝓕.States) :
|
|||
- for the list `[φ1(t = 4), φ2(t = 5), φ3(t = 3), φ4(t = 5)]` this would return `φ2(t = 5)`.
|
||||
It is the state at the position `maxTimeFieldPos φ φs`.
|
||||
-/
|
||||
def maxTimeField (φ : 𝓕.States) (φs : List 𝓕.States) : 𝓕.States :=
|
||||
def maxTimeField (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : 𝓕.FieldOp :=
|
||||
insertionSortMin timeOrderRel φ φs
|
||||
|
||||
/-- Given a list `φ :: φs` of states, the list with the left-most state of maximum
|
||||
|
|
@ -89,15 +89,15 @@ def maxTimeField (φ : 𝓕.States) (φs : List 𝓕.States) : 𝓕.States :=
|
|||
- for the list `[φ1(t = 4), φ2(t = 5), φ3(t = 3), φ4(t = 5)]` this would return
|
||||
`[φ1(t = 4), φ3(t = 3), φ4(t = 5)]`.
|
||||
-/
|
||||
def eraseMaxTimeField (φ : 𝓕.States) (φs : List 𝓕.States) : List 𝓕.States :=
|
||||
def eraseMaxTimeField (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : List 𝓕.FieldOp :=
|
||||
insertionSortDropMinPos timeOrderRel φ φs
|
||||
|
||||
@[simp]
|
||||
lemma eraseMaxTimeField_length (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
lemma eraseMaxTimeField_length (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
(eraseMaxTimeField φ φs).length = φs.length := by
|
||||
simp [eraseMaxTimeField, insertionSortDropMinPos, eraseIdx_length']
|
||||
|
||||
lemma maxTimeFieldPos_lt_eraseMaxTimeField_length_succ (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
lemma maxTimeFieldPos_lt_eraseMaxTimeField_length_succ (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
maxTimeFieldPos φ φs < (eraseMaxTimeField φ φs).length.succ := by
|
||||
simp only [eraseMaxTimeField_length, Nat.succ_eq_add_one]
|
||||
exact maxTimeFieldPos_lt_length φ φs
|
||||
|
|
@ -107,17 +107,17 @@ lemma maxTimeFieldPos_lt_eraseMaxTimeField_length_succ (φ : 𝓕.States) (φs :
|
|||
As an example:
|
||||
- for the list `[φ1(t = 4), φ2(t = 5), φ3(t = 3), φ4(t = 5)]` this would return `⟨1,...⟩`.
|
||||
-/
|
||||
def maxTimeFieldPosFin (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
def maxTimeFieldPosFin (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
Fin (eraseMaxTimeField φ φs).length.succ :=
|
||||
insertionSortMinPosFin timeOrderRel φ φs
|
||||
|
||||
lemma lt_maxTimeFieldPosFin_not_timeOrder (φ : 𝓕.States) (φs : List 𝓕.States)
|
||||
lemma lt_maxTimeFieldPosFin_not_timeOrder (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
|
||||
(i : Fin (eraseMaxTimeField φ φs).length)
|
||||
(hi : (maxTimeFieldPosFin φ φs).succAbove i < maxTimeFieldPosFin φ φs) :
|
||||
¬ timeOrderRel ((eraseMaxTimeField φ φs)[i.val]) (maxTimeField φ φs) := by
|
||||
exact insertionSortMin_lt_mem_insertionSortDropMinPos_of_lt timeOrderRel φ φs i hi
|
||||
|
||||
lemma timeOrder_maxTimeField (φ : 𝓕.States) (φs : List 𝓕.States)
|
||||
lemma timeOrder_maxTimeField (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
|
||||
(i : Fin (eraseMaxTimeField φ φs).length) :
|
||||
timeOrderRel (maxTimeField φ φs) ((eraseMaxTimeField φ φs)[i.val]) := by
|
||||
exact insertionSortMin_lt_mem_insertionSortDropMinPos timeOrderRel φ φs _
|
||||
|
|
@ -125,7 +125,7 @@ lemma timeOrder_maxTimeField (φ : 𝓕.States) (φs : List 𝓕.States)
|
|||
/-- The sign associated with putting a list of states into time order (with
|
||||
the state of greatest time to the left).
|
||||
We pick up a minus sign for every fermion paired crossed. -/
|
||||
def timeOrderSign (φs : List 𝓕.States) : ℂ :=
|
||||
def timeOrderSign (φs : List 𝓕.FieldOp) : ℂ :=
|
||||
Wick.koszulSign 𝓕.statesStatistic 𝓕.timeOrderRel φs
|
||||
|
||||
@[simp]
|
||||
|
|
@ -133,19 +133,19 @@ lemma timeOrderSign_nil : timeOrderSign (𝓕 := 𝓕) [] = 1 := by
|
|||
simp only [timeOrderSign]
|
||||
rfl
|
||||
|
||||
lemma timeOrderSign_pair_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
|
||||
lemma timeOrderSign_pair_ordered {φ ψ : 𝓕.FieldOp} (h : timeOrderRel φ ψ) :
|
||||
timeOrderSign [φ, ψ] = 1 := by
|
||||
simp only [timeOrderSign, Wick.koszulSign, Wick.koszulSignInsert, mul_one, ite_eq_left_iff,
|
||||
ite_eq_right_iff, and_imp]
|
||||
exact fun h' => False.elim (h' h)
|
||||
|
||||
lemma timeOrderSign_pair_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
|
||||
lemma timeOrderSign_pair_not_ordered {φ ψ : 𝓕.FieldOp} (h : ¬ timeOrderRel φ ψ) :
|
||||
timeOrderSign [φ, ψ] = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) := by
|
||||
simp only [timeOrderSign, Wick.koszulSign, Wick.koszulSignInsert, mul_one, instCommGroup.eq_1]
|
||||
rw [if_neg h]
|
||||
simp [FieldStatistic.exchangeSign_eq_if]
|
||||
|
||||
lemma timerOrderSign_of_eraseMaxTimeField (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
lemma timerOrderSign_of_eraseMaxTimeField (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
timeOrderSign (eraseMaxTimeField φ φs) = timeOrderSign (φ :: φs) *
|
||||
𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ (φ :: φs).take (maxTimeFieldPos φ φs)) := by
|
||||
rw [eraseMaxTimeField, insertionSortDropMinPos, timeOrderSign,
|
||||
|
|
@ -156,16 +156,16 @@ lemma timerOrderSign_of_eraseMaxTimeField (φ : 𝓕.States) (φs : List 𝓕.St
|
|||
/-- The time ordering of a list of states. A schematic example is:
|
||||
- `normalOrderList [φ1(t = 4), φ2(t = 5), φ3(t = 3), φ4(t = 5)]` is equal to
|
||||
`[φ2(t = 5), φ4(t = 5), φ1(t = 4), φ3(t = 3)]` -/
|
||||
def timeOrderList (φs : List 𝓕.States) : List 𝓕.States :=
|
||||
def timeOrderList (φs : List 𝓕.FieldOp) : List 𝓕.FieldOp :=
|
||||
List.insertionSort 𝓕.timeOrderRel φs
|
||||
|
||||
lemma timeOrderList_pair_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
|
||||
lemma timeOrderList_pair_ordered {φ ψ : 𝓕.FieldOp} (h : timeOrderRel φ ψ) :
|
||||
timeOrderList [φ, ψ] = [φ, ψ] := by
|
||||
simp only [timeOrderList, List.insertionSort, List.orderedInsert, ite_eq_left_iff,
|
||||
List.cons.injEq, and_true]
|
||||
exact fun h' => False.elim (h' h)
|
||||
|
||||
lemma timeOrderList_pair_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
|
||||
lemma timeOrderList_pair_not_ordered {φ ψ : 𝓕.FieldOp} (h : ¬ timeOrderRel φ ψ) :
|
||||
timeOrderList [φ, ψ] = [ψ, φ] := by
|
||||
simp only [timeOrderList, List.insertionSort, List.orderedInsert, ite_eq_right_iff,
|
||||
List.cons.injEq, and_true]
|
||||
|
|
@ -175,13 +175,13 @@ lemma timeOrderList_pair_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel
|
|||
lemma timeOrderList_nil : timeOrderList (𝓕 := 𝓕) [] = [] := by
|
||||
simp [timeOrderList]
|
||||
|
||||
lemma timeOrderList_eq_maxTimeField_timeOrderList (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
lemma timeOrderList_eq_maxTimeField_timeOrderList (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
|
||||
timeOrderList (φ :: φs) = maxTimeField φ φs :: timeOrderList (eraseMaxTimeField φ φs) := by
|
||||
exact insertionSort_eq_insertionSortMin_cons timeOrderRel φ φs
|
||||
|
||||
/-!
|
||||
|
||||
## Time ordering for CrAnStates
|
||||
## Time ordering for CrAnFieldOp
|
||||
|
||||
-/
|
||||
|
||||
|
|
@ -191,30 +191,30 @@ lemma timeOrderList_eq_maxTimeField_timeOrderList (φ : 𝓕.States) (φs : List
|
|||
|
||||
-/
|
||||
|
||||
/-- The time ordering relation on CrAnStates. -/
|
||||
def crAnTimeOrderRel (a b : 𝓕.CrAnStates) : Prop := 𝓕.timeOrderRel a.1 b.1
|
||||
/-- The time ordering relation on CrAnFieldOp. -/
|
||||
def crAnTimeOrderRel (a b : 𝓕.CrAnFieldOp) : Prop := 𝓕.timeOrderRel a.1 b.1
|
||||
|
||||
/-- The relation `crAnTimeOrderRel` is decidable, but not computablly so due to
|
||||
`Real.decidableLE`. -/
|
||||
noncomputable instance (φ φ' : 𝓕.CrAnStates) : Decidable (crAnTimeOrderRel φ φ') :=
|
||||
noncomputable instance (φ φ' : 𝓕.CrAnFieldOp) : Decidable (crAnTimeOrderRel φ φ') :=
|
||||
inferInstanceAs (Decidable (𝓕.timeOrderRel φ.1 φ'.1))
|
||||
|
||||
/-- Time ordering of `CrAnStates` is total. -/
|
||||
instance : IsTotal 𝓕.CrAnStates 𝓕.crAnTimeOrderRel where
|
||||
/-- Time ordering of `CrAnFieldOp` is total. -/
|
||||
instance : IsTotal 𝓕.CrAnFieldOp 𝓕.crAnTimeOrderRel where
|
||||
total a b := IsTotal.total (r := 𝓕.timeOrderRel) a.1 b.1
|
||||
|
||||
/-- Time ordering of `CrAnStates` is transitive. -/
|
||||
instance : IsTrans 𝓕.CrAnStates 𝓕.crAnTimeOrderRel where
|
||||
/-- Time ordering of `CrAnFieldOp` is transitive. -/
|
||||
instance : IsTrans 𝓕.CrAnFieldOp 𝓕.crAnTimeOrderRel where
|
||||
trans a b c := IsTrans.trans (r := 𝓕.timeOrderRel) a.1 b.1 c.1
|
||||
|
||||
@[simp]
|
||||
lemma crAnTimeOrderRel_refl (φ : 𝓕.CrAnStates) : crAnTimeOrderRel φ φ := by
|
||||
lemma crAnTimeOrderRel_refl (φ : 𝓕.CrAnFieldOp) : crAnTimeOrderRel φ φ := by
|
||||
exact (IsTotal.to_isRefl (r := 𝓕.crAnTimeOrderRel)).refl φ
|
||||
|
||||
/-- The sign associated with putting a list of `CrAnStates` into time order (with
|
||||
/-- The sign associated with putting a list of `CrAnFieldOp` into time order (with
|
||||
the state of greatest time to the left).
|
||||
We pick up a minus sign for every fermion paired crossed. -/
|
||||
def crAnTimeOrderSign (φs : List 𝓕.CrAnStates) : ℂ :=
|
||||
def crAnTimeOrderSign (φs : List 𝓕.CrAnFieldOp) : ℂ :=
|
||||
Wick.koszulSign 𝓕.crAnStatistics 𝓕.crAnTimeOrderRel φs
|
||||
|
||||
@[simp]
|
||||
|
|
@ -222,45 +222,45 @@ lemma crAnTimeOrderSign_nil : crAnTimeOrderSign (𝓕 := 𝓕) [] = 1 := by
|
|||
simp only [crAnTimeOrderSign]
|
||||
rfl
|
||||
|
||||
lemma crAnTimeOrderSign_pair_ordered {φ ψ : 𝓕.CrAnStates} (h : crAnTimeOrderRel φ ψ) :
|
||||
lemma crAnTimeOrderSign_pair_ordered {φ ψ : 𝓕.CrAnFieldOp} (h : crAnTimeOrderRel φ ψ) :
|
||||
crAnTimeOrderSign [φ, ψ] = 1 := by
|
||||
simp only [crAnTimeOrderSign, Wick.koszulSign, Wick.koszulSignInsert, mul_one, ite_eq_left_iff,
|
||||
ite_eq_right_iff, and_imp]
|
||||
exact fun h' => False.elim (h' h)
|
||||
|
||||
lemma crAnTimeOrderSign_pair_not_ordered {φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) :
|
||||
lemma crAnTimeOrderSign_pair_not_ordered {φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) :
|
||||
crAnTimeOrderSign [φ, ψ] = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) := by
|
||||
simp only [crAnTimeOrderSign, Wick.koszulSign, Wick.koszulSignInsert, mul_one, instCommGroup.eq_1]
|
||||
rw [if_neg h]
|
||||
simp [FieldStatistic.exchangeSign_eq_if]
|
||||
|
||||
lemma crAnTimeOrderSign_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs φs' : List 𝓕.CrAnStates) :
|
||||
lemma crAnTimeOrderSign_swap_eq_time {φ ψ : 𝓕.CrAnFieldOp}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs φs' : List 𝓕.CrAnFieldOp) :
|
||||
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 :=
|
||||
/-- Sort a list of `CrAnFieldOp` based on `crAnTimeOrderRel`. -/
|
||||
def crAnTimeOrderList (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp :=
|
||||
List.insertionSort 𝓕.crAnTimeOrderRel φs
|
||||
|
||||
@[simp]
|
||||
lemma crAnTimeOrderList_nil : crAnTimeOrderList (𝓕 := 𝓕) [] = [] := by
|
||||
simp [crAnTimeOrderList]
|
||||
|
||||
lemma crAnTimeOrderList_pair_ordered {φ ψ : 𝓕.CrAnStates} (h : crAnTimeOrderRel φ ψ) :
|
||||
lemma crAnTimeOrderList_pair_ordered {φ ψ : 𝓕.CrAnFieldOp} (h : crAnTimeOrderRel φ ψ) :
|
||||
crAnTimeOrderList [φ, ψ] = [φ, ψ] := by
|
||||
simp only [crAnTimeOrderList, List.insertionSort, List.orderedInsert, ite_eq_left_iff,
|
||||
List.cons.injEq, and_true]
|
||||
exact fun h' => False.elim (h' h)
|
||||
|
||||
lemma crAnTimeOrderList_pair_not_ordered {φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) :
|
||||
lemma crAnTimeOrderList_pair_not_ordered {φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) :
|
||||
crAnTimeOrderList [φ, ψ] = [ψ, φ] := by
|
||||
simp only [crAnTimeOrderList, List.insertionSort, List.orderedInsert, ite_eq_right_iff,
|
||||
List.cons.injEq, and_true]
|
||||
exact fun h' => False.elim (h h')
|
||||
|
||||
lemma orderedInsert_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs : List 𝓕.CrAnStates) :
|
||||
lemma orderedInsert_swap_eq_time {φ ψ : 𝓕.CrAnFieldOp}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) (φs : List 𝓕.CrAnFieldOp) :
|
||||
List.orderedInsert crAnTimeOrderRel φ (List.orderedInsert crAnTimeOrderRel ψ φs) =
|
||||
List.takeWhile (fun b => ¬ crAnTimeOrderRel ψ b) φs ++ φ :: ψ ::
|
||||
List.dropWhile (fun b => ¬ crAnTimeOrderRel ψ b) φs := by
|
||||
|
|
@ -268,7 +268,7 @@ lemma orderedInsert_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
|||
simp only [decide_not]
|
||||
rw [List.orderedInsert_eq_take_drop]
|
||||
simp only [decide_not]
|
||||
have h1 (b : 𝓕.CrAnStates) : (crAnTimeOrderRel φ b) ↔ (crAnTimeOrderRel ψ b) :=
|
||||
have h1 (b : 𝓕.CrAnFieldOp) : (crAnTimeOrderRel φ b) ↔ (crAnTimeOrderRel ψ b) :=
|
||||
Iff.intro (fun h => IsTrans.trans _ _ _ h2 h) (fun h => IsTrans.trans _ _ _ h1 h)
|
||||
simp only [h1]
|
||||
rw [List.takeWhile_append]
|
||||
|
|
@ -286,12 +286,12 @@ lemma orderedInsert_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
|||
intro y hy
|
||||
simpa using List.mem_takeWhile_imp hy
|
||||
|
||||
lemma orderedInsert_in_swap_eq_time {φ ψ φ': 𝓕.CrAnStates} (h1 : crAnTimeOrderRel φ ψ)
|
||||
(h2 : crAnTimeOrderRel ψ φ) : (φs φs' : List 𝓕.CrAnStates) → ∃ l1 l2,
|
||||
lemma orderedInsert_in_swap_eq_time {φ ψ φ': 𝓕.CrAnFieldOp} (h1 : crAnTimeOrderRel φ ψ)
|
||||
(h2 : crAnTimeOrderRel ψ φ) : (φs φs' : List 𝓕.CrAnFieldOp) → ∃ l1 l2,
|
||||
List.orderedInsert crAnTimeOrderRel φ' (φs ++ φ :: ψ :: φs') = l1 ++ φ :: ψ :: l2 ∧
|
||||
List.orderedInsert crAnTimeOrderRel φ' (φs ++ ψ :: φ :: φs') = l1 ++ ψ :: φ :: l2
|
||||
| [], φs' => by
|
||||
have h1 (b : 𝓕.CrAnStates) : (crAnTimeOrderRel b φ) ↔ (crAnTimeOrderRel b ψ) :=
|
||||
have h1 (b : 𝓕.CrAnFieldOp) : (crAnTimeOrderRel b φ) ↔ (crAnTimeOrderRel b ψ) :=
|
||||
Iff.intro (fun h => IsTrans.trans _ _ _ h h1) (fun h => IsTrans.trans _ _ _ h h2)
|
||||
by_cases h : crAnTimeOrderRel φ' φ
|
||||
· simp only [List.orderedInsert, h, ↓reduceIte, ← h1 φ']
|
||||
|
|
@ -312,10 +312,10 @@ lemma orderedInsert_in_swap_eq_time {φ ψ φ': 𝓕.CrAnStates} (h1 : crAnTimeO
|
|||
use (φ'' :: l1), l2
|
||||
simp
|
||||
|
||||
lemma crAnTimeOrderList_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
||||
lemma crAnTimeOrderList_swap_eq_time {φ ψ : 𝓕.CrAnFieldOp}
|
||||
(h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) :
|
||||
(φs φs' : List 𝓕.CrAnStates) →
|
||||
∃ (l1 l2 : List 𝓕.CrAnStates),
|
||||
(φs φs' : List 𝓕.CrAnFieldOp) →
|
||||
∃ (l1 l2 : List 𝓕.CrAnFieldOp),
|
||||
crAnTimeOrderList (φs ++ φ :: ψ :: φs') = l1 ++ φ :: ψ :: l2 ∧
|
||||
crAnTimeOrderList (φs ++ ψ :: φ :: φs') = l1 ++ ψ :: φ :: l2
|
||||
| [], φs' => by
|
||||
|
|
@ -325,7 +325,7 @@ lemma crAnTimeOrderList_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
|||
List.dropWhile (fun b => ¬ crAnTimeOrderRel ψ b) (List.insertionSort crAnTimeOrderRel φs')
|
||||
apply And.intro
|
||||
· exact orderedInsert_swap_eq_time h1 h2 _
|
||||
· have h1' (b : 𝓕.CrAnStates) : (crAnTimeOrderRel φ b) ↔ (crAnTimeOrderRel ψ b) :=
|
||||
· have h1' (b : 𝓕.CrAnFieldOp) : (crAnTimeOrderRel φ b) ↔ (crAnTimeOrderRel ψ b) :=
|
||||
Iff.intro (fun h => IsTrans.trans _ _ _ h2 h) (fun h => IsTrans.trans _ _ _ h1 h)
|
||||
simp only [← h1', decide_not]
|
||||
simpa using orderedInsert_swap_eq_time h2 h1 _
|
||||
|
|
@ -344,8 +344,8 @@ lemma crAnTimeOrderList_swap_eq_time {φ ψ : 𝓕.CrAnStates}
|
|||
## Relationship to sections
|
||||
-/
|
||||
|
||||
lemma koszulSignInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.States} {ψ : 𝓕.CrAnStates}
|
||||
(h : ψ.1 = φ) : {φs : List 𝓕.States} → (ψs : CrAnSection φs) →
|
||||
lemma koszulSignInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.FieldOp} {ψ : 𝓕.CrAnFieldOp}
|
||||
(h : ψ.1 = φ) : {φs : List 𝓕.FieldOp} → (ψs : CrAnSection φs) →
|
||||
Wick.koszulSignInsert 𝓕.crAnStatistics 𝓕.crAnTimeOrderRel ψ ψs.1 =
|
||||
Wick.koszulSignInsert 𝓕.statesStatistic 𝓕.timeOrderRel φ φs
|
||||
| [], ⟨[], h⟩ => by
|
||||
|
|
@ -357,14 +357,14 @@ lemma koszulSignInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.States} {ψ :
|
|||
rw [hi]
|
||||
congr
|
||||
· exact h1.1
|
||||
· simp only [crAnStatistics, crAnStatesToStates, Function.comp_apply]
|
||||
· simp only [crAnStatistics, crAnFieldOpToFieldOp, Function.comp_apply]
|
||||
congr
|
||||
· simp only [crAnStatistics, crAnStatesToStates, Function.comp_apply]
|
||||
· simp only [crAnStatistics, crAnFieldOpToFieldOp, Function.comp_apply]
|
||||
congr
|
||||
exact h1.1
|
||||
|
||||
@[simp]
|
||||
lemma crAnTimeOrderSign_crAnSection : {φs : List 𝓕.States} → (ψs : CrAnSection φs) →
|
||||
lemma crAnTimeOrderSign_crAnSection : {φs : List 𝓕.FieldOp} → (ψs : CrAnSection φs) →
|
||||
crAnTimeOrderSign ψs.1 = timeOrderSign φs
|
||||
| [], ⟨[], h⟩ => by
|
||||
simp
|
||||
|
|
@ -375,9 +375,9 @@ lemma crAnTimeOrderSign_crAnSection : {φs : List 𝓕.States} → (ψs : CrAnSe
|
|||
· rw [koszulSignInsert_crAnTimeOrderRel_crAnSection h.1 ⟨ψs, h.2⟩]
|
||||
· exact crAnTimeOrderSign_crAnSection ⟨ψs, h.2⟩
|
||||
|
||||
lemma orderedInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.States} {ψ : 𝓕.CrAnStates}
|
||||
(h : ψ.1 = φ) : {φs : List 𝓕.States} → (ψs : CrAnSection φs) →
|
||||
(List.orderedInsert 𝓕.crAnTimeOrderRel ψ ψs.1).map 𝓕.crAnStatesToStates =
|
||||
lemma orderedInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.FieldOp} {ψ : 𝓕.CrAnFieldOp}
|
||||
(h : ψ.1 = φ) : {φs : List 𝓕.FieldOp} → (ψs : CrAnSection φs) →
|
||||
(List.orderedInsert 𝓕.crAnTimeOrderRel ψ ψs.1).map 𝓕.crAnFieldOpToFieldOp =
|
||||
List.orderedInsert 𝓕.timeOrderRel φ φs
|
||||
| [], ⟨[], _⟩ => by
|
||||
simp only [List.orderedInsert, List.map_cons, List.map_nil, List.cons.injEq, and_true]
|
||||
|
|
@ -388,18 +388,18 @@ lemma orderedInsert_crAnTimeOrderRel_crAnSection {φ : 𝓕.States} {ψ : 𝓕.C
|
|||
by_cases hr : timeOrderRel φ φ'
|
||||
· simp only [hr, ↓reduceIte]
|
||||
rw [← h1.1] at hr
|
||||
simp only [crAnStatesToStates] at hr
|
||||
simp only [crAnFieldOpToFieldOp] at hr
|
||||
simp only [hr, ↓reduceIte, List.map_cons, List.cons.injEq]
|
||||
exact And.intro h (And.intro h1.1 h1.2)
|
||||
· simp only [hr, ↓reduceIte]
|
||||
rw [← h1.1] at hr
|
||||
simp only [crAnStatesToStates] at hr
|
||||
simp only [crAnFieldOpToFieldOp] at hr
|
||||
simp only [hr, ↓reduceIte, List.map_cons, List.cons.injEq]
|
||||
apply And.intro h1.1
|
||||
exact orderedInsert_crAnTimeOrderRel_crAnSection h ⟨ψs, h1.2⟩
|
||||
|
||||
lemma crAnTimeOrderList_crAnSection_is_crAnSection : {φs : List 𝓕.States} → (ψs : CrAnSection φs) →
|
||||
(crAnTimeOrderList ψs.1).map 𝓕.crAnStatesToStates = timeOrderList φs
|
||||
lemma crAnTimeOrderList_crAnSection_is_crAnSection : {φs : List 𝓕.FieldOp} → (ψs : CrAnSection φs) →
|
||||
(crAnTimeOrderList ψs.1).map 𝓕.crAnFieldOpToFieldOp = timeOrderList φs
|
||||
| [], ⟨[], h⟩ => by
|
||||
simp
|
||||
| φ :: φs, ⟨ψ :: ψs, h⟩ => by
|
||||
|
|
@ -409,12 +409,12 @@ lemma crAnTimeOrderList_crAnSection_is_crAnSection : {φs : List 𝓕.States}
|
|||
crAnTimeOrderList_crAnSection_is_crAnSection ⟨ψs, h.2⟩⟩
|
||||
|
||||
/-- Time ordering of sections of a list of states. -/
|
||||
def crAnSectionTimeOrder (φs : List 𝓕.States) (ψs : CrAnSection φs) :
|
||||
def crAnSectionTimeOrder (φs : List 𝓕.FieldOp) (ψs : CrAnSection φs) :
|
||||
CrAnSection (timeOrderList φs) :=
|
||||
⟨crAnTimeOrderList ψs.1, crAnTimeOrderList_crAnSection_is_crAnSection ψs⟩
|
||||
|
||||
lemma orderedInsert_crAnTimeOrderRel_injective {ψ ψ' : 𝓕.CrAnStates} (h : ψ.1 = ψ'.1) :
|
||||
{φs : List 𝓕.States} → (ψs ψs' : 𝓕.CrAnSection φs) →
|
||||
lemma orderedInsert_crAnTimeOrderRel_injective {ψ ψ' : 𝓕.CrAnFieldOp} (h : ψ.1 = ψ'.1) :
|
||||
{φs : List 𝓕.FieldOp} → (ψs ψs' : 𝓕.CrAnSection φs) →
|
||||
(ho : List.orderedInsert crAnTimeOrderRel ψ ψs.1 =
|
||||
List.orderedInsert crAnTimeOrderRel ψ' ψs'.1) → ψ = ψ' ∧ ψs = ψs'
|
||||
| [], ⟨[], _⟩, ⟨[], _⟩, h => by
|
||||
|
|
@ -430,7 +430,7 @@ lemma orderedInsert_crAnTimeOrderRel_injective {ψ ψ' : 𝓕.CrAnStates} (h :
|
|||
· simp_all
|
||||
· simp only [crAnTimeOrderRel] at hr hr2
|
||||
simp_all only
|
||||
rw [crAnStatesToStates] at h1 h1'
|
||||
rw [crAnFieldOpToFieldOp] at h1 h1'
|
||||
rw [h1.1] at hr
|
||||
rw [h1'.1] at hr2
|
||||
exact False.elim (hr2 hr)
|
||||
|
|
@ -438,7 +438,7 @@ lemma orderedInsert_crAnTimeOrderRel_injective {ψ ψ' : 𝓕.CrAnStates} (h :
|
|||
by_cases hr2 : crAnTimeOrderRel ψ' ψ1'
|
||||
· simp only [crAnTimeOrderRel] at hr hr2
|
||||
simp_all only
|
||||
rw [crAnStatesToStates] at h1 h1'
|
||||
rw [crAnFieldOpToFieldOp] at h1 h1'
|
||||
rw [h1.1] at hr
|
||||
rw [h1'.1] at hr2
|
||||
exact False.elim (hr hr2)
|
||||
|
|
@ -450,7 +450,7 @@ lemma orderedInsert_crAnTimeOrderRel_injective {ψ ψ' : 𝓕.CrAnStates} (h :
|
|||
rw [Subtype.eq_iff] at ih'
|
||||
exact ih'.2
|
||||
|
||||
lemma crAnSectionTimeOrder_injective : {φs : List 𝓕.States} →
|
||||
lemma crAnSectionTimeOrder_injective : {φs : List 𝓕.FieldOp} →
|
||||
Function.Injective (𝓕.crAnSectionTimeOrder φs)
|
||||
| [], ⟨[], _⟩, ⟨[], _⟩ => by
|
||||
simp
|
||||
|
|
@ -462,7 +462,7 @@ lemma crAnSectionTimeOrder_injective : {φs : List 𝓕.States} →
|
|||
rw [Subtype.eq_iff] at h1
|
||||
simp only [crAnTimeOrderList, List.insertionSort] at h1
|
||||
simp only [List.map_cons, List.cons.injEq] at h h'
|
||||
rw [crAnStatesToStates] at h h'
|
||||
rw [crAnFieldOpToFieldOp] at h h'
|
||||
have hin := orderedInsert_crAnTimeOrderRel_injective (by rw [h.1, h'.1])
|
||||
(𝓕.crAnSectionTimeOrder φs ⟨ψs, h.2⟩)
|
||||
(𝓕.crAnSectionTimeOrder φs ⟨ψs', h'.2⟩) h1
|
||||
|
|
@ -471,7 +471,7 @@ lemma crAnSectionTimeOrder_injective : {φs : List 𝓕.States} →
|
|||
rw [Subtype.ext_iff] at hl
|
||||
simpa using hl
|
||||
|
||||
lemma crAnSectionTimeOrder_bijective (φs : List 𝓕.States) :
|
||||
lemma crAnSectionTimeOrder_bijective (φs : List 𝓕.FieldOp) :
|
||||
Function.Bijective (𝓕.crAnSectionTimeOrder φs) := by
|
||||
rw [Fintype.bijective_iff_injective_and_card]
|
||||
apply And.intro crAnSectionTimeOrder_injective
|
||||
|
|
@ -479,7 +479,7 @@ lemma crAnSectionTimeOrder_bijective (φs : List 𝓕.States) :
|
|||
simp only [timeOrderList]
|
||||
exact List.Perm.symm (List.perm_insertionSort timeOrderRel φs)
|
||||
|
||||
lemma sum_crAnSections_timeOrder {φs : List 𝓕.States} [AddCommMonoid M]
|
||||
lemma sum_crAnSections_timeOrder {φs : List 𝓕.FieldOp} [AddCommMonoid M]
|
||||
(f : CrAnSection (timeOrderList φs) → M) : ∑ s, f s = ∑ s, f (𝓕.crAnSectionTimeOrder φs s) := by
|
||||
erw [(Equiv.ofBijective _ (𝓕.crAnSectionTimeOrder_bijective φs)).sum_comp]
|
||||
|
||||
|
|
@ -489,18 +489,18 @@ lemma sum_crAnSections_timeOrder {φs : List 𝓕.States} [AddCommMonoid M]
|
|||
|
||||
-/
|
||||
|
||||
/-- The time ordering relation on `CrAnStates` such that if two CrAnStates have the same
|
||||
/-- The time ordering relation on `CrAnFieldOp` such that if two CrAnFieldOp have the same
|
||||
time, we normal order them. -/
|
||||
def normTimeOrderRel (a b : 𝓕.CrAnStates) : Prop :=
|
||||
def normTimeOrderRel (a b : 𝓕.CrAnFieldOp) : Prop :=
|
||||
crAnTimeOrderRel a b ∧ (crAnTimeOrderRel b a → normalOrderRel a b)
|
||||
|
||||
/-- The relation `normTimeOrderRel` is decidable, but not computablly so due to
|
||||
`Real.decidableLE`. -/
|
||||
noncomputable instance (φ φ' : 𝓕.CrAnStates) : Decidable (normTimeOrderRel φ φ') :=
|
||||
noncomputable instance (φ φ' : 𝓕.CrAnFieldOp) : Decidable (normTimeOrderRel φ φ') :=
|
||||
instDecidableAnd
|
||||
|
||||
/-- Norm-Time ordering of `CrAnStates` is total. -/
|
||||
instance : IsTotal 𝓕.CrAnStates 𝓕.normTimeOrderRel where
|
||||
/-- Norm-Time ordering of `CrAnFieldOp` is total. -/
|
||||
instance : IsTotal 𝓕.CrAnFieldOp 𝓕.normTimeOrderRel where
|
||||
total a b := by
|
||||
simp only [normTimeOrderRel]
|
||||
match IsTotal.total (r := 𝓕.crAnTimeOrderRel) a b,
|
||||
|
|
@ -518,8 +518,8 @@ instance : IsTotal 𝓕.CrAnStates 𝓕.normTimeOrderRel where
|
|||
· simp [hn]
|
||||
| Or.inr h1, Or.inr h2 => simp [h1, h2]
|
||||
|
||||
/-- Norm-Time ordering of `CrAnStates` is transitive. -/
|
||||
instance : IsTrans 𝓕.CrAnStates 𝓕.normTimeOrderRel where
|
||||
/-- Norm-Time ordering of `CrAnFieldOp` is transitive. -/
|
||||
instance : IsTrans 𝓕.CrAnFieldOp 𝓕.normTimeOrderRel where
|
||||
trans a b c := by
|
||||
intro h1 h2
|
||||
simp_all only [normTimeOrderRel]
|
||||
|
|
@ -530,14 +530,14 @@ instance : IsTrans 𝓕.CrAnStates 𝓕.normTimeOrderRel where
|
|||
· exact IsTrans.trans _ _ _ h2.1 hc
|
||||
· exact IsTrans.trans _ _ _ hc h1.1
|
||||
|
||||
/-- The sign associated with putting a list of `CrAnStates` into normal-time order (with
|
||||
/-- The sign associated with putting a list of `CrAnFieldOp` into normal-time order (with
|
||||
the state of greatest time to the left).
|
||||
We pick up a minus sign for every fermion paired crossed. -/
|
||||
def normTimeOrderSign (φs : List 𝓕.CrAnStates) : ℂ :=
|
||||
def normTimeOrderSign (φs : List 𝓕.CrAnFieldOp) : ℂ :=
|
||||
Wick.koszulSign 𝓕.crAnStatistics 𝓕.normTimeOrderRel φs
|
||||
|
||||
/-- Sort a list of `CrAnStates` based on `normTimeOrderRel`. -/
|
||||
def normTimeOrderList (φs : List 𝓕.CrAnStates) : List 𝓕.CrAnStates :=
|
||||
/-- Sort a list of `CrAnFieldOp` based on `normTimeOrderRel`. -/
|
||||
def normTimeOrderList (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp :=
|
||||
List.insertionSort 𝓕.normTimeOrderRel φs
|
||||
|
||||
end
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue