DibyashanuPati/PhysLean
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: Rename States to FieldOps

Browse source
This commit is contained in:
jstoobysmith 2025-02-03 11:28:14 +00:00
parent 171e80fc04
commit 8f41de5785
36 changed files with 946 additions and 946 deletions
Download patch file Download diff file Expand all files Collapse all files

102
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/Basic.lean
View file

@ -23,13 +23,13 @@ variable (𝓕 : FieldSpecification)
This contains e.g. the super-commutor of two creation operators. -/
def fieldOpIdealSet : Set (FieldOpFreeAlgebra 𝓕) :=
{ x |
(∃ (φ1 φ2 φ3 : 𝓕.CrAnStates),
(∃ (φ1 φ2 φ3 : 𝓕.CrAnFieldOp),
x = [ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca)
∨ (∃ (φc φc' : 𝓕.CrAnStates) (_ : 𝓕 |>ᶜ φc = .create) (_ : 𝓕 |>ᶜ φc' = .create),
∨ (∃ (φc φc' : 𝓕.CrAnFieldOp) (_ : 𝓕 |>ᶜ φc = .create) (_ : 𝓕 |>ᶜ φc' = .create),
x = [ofCrAnOpF φc, ofCrAnOpF φc']ₛca)
∨ (∃ (φa φa' : 𝓕.CrAnStates) (_ : 𝓕 |>ᶜ φa = .annihilate) (_ : 𝓕 |>ᶜ φa' = .annihilate),
∨ (∃ (φa φa' : 𝓕.CrAnFieldOp) (_ : 𝓕 |>ᶜ φa = .annihilate) (_ : 𝓕 |>ᶜ φa' = .annihilate),
x = [ofCrAnOpF φa, ofCrAnOpF φa']ₛca)
∨ (∃ (φ φ' : 𝓕.CrAnStates) (_ : ¬ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φ')),
∨ (∃ (φ φ' : 𝓕.CrAnFieldOp) (_ : ¬ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φ')),
x = [ofCrAnOpF φ, ofCrAnOpF φ']ₛca)}
/-- The algebra spanned by cr and an parts of fields, with appropriate super-commutors
@ -72,7 +72,7 @@ lemma ι_of_mem_fieldOpIdealSet (x : FieldOpFreeAlgebra 𝓕) (hx : x ∈ 𝓕.f
refine RingConGen.Rel.of x 0 ?_
simpa using hx
lemma ι_superCommuteF_of_create_create (φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = .create)
lemma ι_superCommuteF_of_create_create (φc φc' : 𝓕.CrAnFieldOp) (hφc : 𝓕 |>ᶜ φc = .create)
(hφc' : 𝓕 |>ᶜ φc' = .create) : ι [ofCrAnOpF φc, ofCrAnOpF φc']ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
simp only [fieldOpIdealSet, exists_and_left, Set.mem_setOf_eq]
@ -81,7 +81,7 @@ lemma ι_superCommuteF_of_create_create (φc φc' : 𝓕.CrAnStates) (hφc :
left
use φc, φc', hφc, hφc'
lemma ι_superCommuteF_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
lemma ι_superCommuteF_of_annihilate_annihilate (φa φa' : 𝓕.CrAnFieldOp)
(hφa : 𝓕 |>ᶜ φa = .annihilate) (hφa' : 𝓕 |>ᶜ φa' = .annihilate) :
ι [ofCrAnOpF φa, ofCrAnOpF φa']ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
@ -92,7 +92,7 @@ lemma ι_superCommuteF_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
left
use φa, φa', hφa, hφa'
lemma ι_superCommuteF_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
lemma ι_superCommuteF_of_diff_statistic {φ ψ : 𝓕.CrAnFieldOp}
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : ι [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
simp only [fieldOpIdealSet, exists_prop, exists_and_left, Set.mem_setOf_eq]
@ -101,7 +101,7 @@ lemma ι_superCommuteF_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
right
use φ, ψ
lemma ι_superCommuteF_zero_of_fermionic (φ ψ : 𝓕.CrAnStates)
lemma ι_superCommuteF_zero_of_fermionic (φ ψ : 𝓕.CrAnFieldOp)
(h : [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca ∈ statisticSubmodule fermionic) :
ι [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca = 0 := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton] at h ⊢
@ -111,7 +111,7 @@ lemma ι_superCommuteF_zero_of_fermionic (φ ψ : 𝓕.CrAnStates)
simpa using h
· simp [h]
lemma ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_zero (φ ψ : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_zero (φ ψ : 𝓕.CrAnFieldOp) :
[ofCrAnOpF φ, ofCrAnOpF ψ]ₛca ∈ statisticSubmodule bosonic ∨
ι [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca = 0 := by
rcases superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic [φ] [ψ] with h | h
@ -127,14 +127,14 @@ lemma ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_zero (φ ψ : 𝓕.CrAnSta
-/
@[simp]
lemma ι_superCommuteF_ofCrAnOpF_superCommuteF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnOpF_superCommuteF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 φ3 : 𝓕.CrAnFieldOp) :
ι [ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
simp only [fieldOpIdealSet, exists_prop, exists_and_left, Set.mem_setOf_eq]
left
use φ1, φ2, φ3
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 φ3 : 𝓕.CrAnFieldOp) :
ι [[ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca, ofCrAnOpF φ3]ₛca = 0 := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
rcases superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic [φ1] [φ2] with h | h
@ -146,8 +146,8 @@ lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 φ3
· rw [superCommuteF_fermionic_fermionic_symm h h']
simp [ofCrAnListF_singleton]
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnListF (φ1 φ2 : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) :
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnListF (φ1 φ2 : 𝓕.CrAnFieldOp)
(φs : List 𝓕.CrAnFieldOp) :
ι [[ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca, ofCrAnListF φs]ₛca = 0 := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
rcases superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic [φ1] [φ2] with h | h
@ -157,7 +157,7 @@ lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnListF (φ1 φ2 :
simp [ofCrAnListF_singleton, ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_ofCrAnOpF]
@[simp]
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_fieldOpFreeAlgebra (φ1 φ2 : 𝓕.CrAnStates)
lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_fieldOpFreeAlgebra (φ1 φ2 : 𝓕.CrAnFieldOp)
(a : 𝓕.FieldOpFreeAlgebra) : ι [[ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca, a]ₛca = 0 := by
change (ι.toLinearMap ∘ₗ superCommuteF [ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca) a = _
have h1 : (ι.toLinearMap ∘ₗ superCommuteF [ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca) = 0 := by
@ -166,7 +166,7 @@ lemma ι_superCommuteF_superCommuteF_ofCrAnOpF_ofCrAnOpF_fieldOpFreeAlgebra (φ1
rw [h1]
simp
lemma ι_commute_fieldOpFreeAlgebra_superCommuteF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 : 𝓕.CrAnStates)
lemma ι_commute_fieldOpFreeAlgebra_superCommuteF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 : 𝓕.CrAnFieldOp)
(a : 𝓕.FieldOpFreeAlgebra) : ι a * ι [ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca -
ι [ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca * ι a = 0 := by
rcases ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_zero φ1 φ2 with h | h
@ -177,7 +177,7 @@ lemma ι_commute_fieldOpFreeAlgebra_superCommuteF_ofCrAnOpF_ofCrAnOpF (φ1 φ2 :
simp
· simp
lemma ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_mem_center (φ ψ : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_mem_center (φ ψ : 𝓕.CrAnFieldOp) :
ι [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca ∈ Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
rw [Subalgebra.mem_center_iff]
intro a
@ -428,111 +428,111 @@ lemma ι_eq_zero_iff_ι_bosonicProj_fermonicProj_zero (x : FieldOpFreeAlgebra
-/
/-- An element of `FieldOpAlgebra` from a `States`. -/
def ofFieldOp (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofFieldOpF φ)
/-- An element of `FieldOpAlgebra` from a `FieldOp`. -/
def ofFieldOp (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (ofFieldOpF φ)
lemma ofFieldOp_eq_ι_ofFieldOpF (φ : 𝓕.States) : ofFieldOp φ = ι (ofFieldOpF φ) := rfl
lemma ofFieldOp_eq_ι_ofFieldOpF (φ : 𝓕.FieldOp) : ofFieldOp φ = ι (ofFieldOpF φ) := rfl
/-- An element of `FieldOpAlgebra` from a list of `States`. -/
def ofFieldOpList (φs : List 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofFieldOpListF φs)
/-- An element of `FieldOpAlgebra` from a list of `FieldOp`. -/
def ofFieldOpList (φs : List 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (ofFieldOpListF φs)
lemma ofFieldOpList_eq_ι_ofFieldOpListF (φs : List 𝓕.States) :
lemma ofFieldOpList_eq_ι_ofFieldOpListF (φs : List 𝓕.FieldOp) :
ofFieldOpList φs = ι (ofFieldOpListF φs) := rfl
lemma ofFieldOpList_append (φs ψs : List 𝓕.States) :
lemma ofFieldOpList_append (φs ψs : List 𝓕.FieldOp) :
ofFieldOpList (φs ++ ψs) = ofFieldOpList φs * ofFieldOpList ψs := by
simp only [ofFieldOpList]
rw [ofFieldOpListF_append]
simp
lemma ofFieldOpList_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma ofFieldOpList_cons (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
ofFieldOpList (φ :: φs) = ofFieldOp φ * ofFieldOpList φs := by
simp only [ofFieldOpList]
rw [ofFieldOpListF_cons]
simp only [map_mul]
rfl
lemma ofFieldOpList_singleton (φ : 𝓕.States) :
lemma ofFieldOpList_singleton (φ : 𝓕.FieldOp) :
ofFieldOpList [φ] = ofFieldOp φ := by
simp only [ofFieldOpList, ofFieldOp, ofFieldOpListF_singleton]
/-- An element of `FieldOpAlgebra` from a `CrAnStates`. -/
def ofCrAnFieldOp (φ : 𝓕.CrAnStates) : 𝓕.FieldOpAlgebra := ι (ofCrAnOpF φ)
/-- An element of `FieldOpAlgebra` from a `CrAnFieldOp`. -/
def ofCrAnFieldOp (φ : 𝓕.CrAnFieldOp) : 𝓕.FieldOpAlgebra := ι (ofCrAnOpF φ)
lemma ofCrAnFieldOp_eq_ι_ofCrAnOpF (φ : 𝓕.CrAnStates) :
lemma ofCrAnFieldOp_eq_ι_ofCrAnOpF (φ : 𝓕.CrAnFieldOp) :
ofCrAnFieldOp φ = ι (ofCrAnOpF φ) := rfl
lemma ofFieldOp_eq_sum (φ : 𝓕.States) :
ofFieldOp φ = (∑ i : 𝓕.statesToCrAnType φ, ofCrAnFieldOp ⟨φ, i⟩) := by
lemma ofFieldOp_eq_sum (φ : 𝓕.FieldOp) :
ofFieldOp φ = (∑ i : 𝓕.fieldOpToCrAnType φ, ofCrAnFieldOp ⟨φ, i⟩) := by
rw [ofFieldOp, ofFieldOpF]
simp only [map_sum]
rfl
/-- An element of `FieldOpAlgebra` from a list of `CrAnStates`. -/
def ofCrAnFieldOpList (φs : List 𝓕.CrAnStates) : 𝓕.FieldOpAlgebra := ι (ofCrAnListF φs)
/-- An element of `FieldOpAlgebra` from a list of `CrAnFieldOp`. -/
def ofCrAnFieldOpList (φs : List 𝓕.CrAnFieldOp) : 𝓕.FieldOpAlgebra := ι (ofCrAnListF φs)
lemma ofCrAnFieldOpList_eq_ι_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma ofCrAnFieldOpList_eq_ι_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
ofCrAnFieldOpList φs = ι (ofCrAnListF φs) := rfl
lemma ofCrAnFieldOpList_append (φs ψs : List 𝓕.CrAnStates) :
lemma ofCrAnFieldOpList_append (φs ψs : List 𝓕.CrAnFieldOp) :
ofCrAnFieldOpList (φs ++ ψs) = ofCrAnFieldOpList φs * ofCrAnFieldOpList ψs := by
simp only [ofCrAnFieldOpList]
rw [ofCrAnListF_append]
simp
lemma ofCrAnFieldOpList_singleton (φ : 𝓕.CrAnStates) :
lemma ofCrAnFieldOpList_singleton (φ : 𝓕.CrAnFieldOp) :
ofCrAnFieldOpList [φ] = ofCrAnFieldOp φ := by
simp only [ofCrAnFieldOpList, ofCrAnFieldOp, ofCrAnListF_singleton]
lemma ofFieldOpList_eq_sum (φs : List 𝓕.States) :
lemma ofFieldOpList_eq_sum (φs : List 𝓕.FieldOp) :
ofFieldOpList φs = ∑ s : CrAnSection φs, ofCrAnFieldOpList s.1 := by
rw [ofFieldOpList, ofFieldOpListF_sum]
simp only [map_sum]
rfl
/-- The annihilation part of a state. -/
def anPart (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (anPartF φ)
def anPart (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (anPartF φ)
lemma anPart_eq_ι_anPartF (φ : 𝓕.States) : anPart φ = ι (anPartF φ) := rfl
lemma anPart_eq_ι_anPartF (φ : 𝓕.FieldOp) : anPart φ = ι (anPartF φ) := rfl
@[simp]
lemma anPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPart (States.inAsymp φ) = 0 := by
anPart (FieldOp.inAsymp φ) = 0 := by
simp [anPart, anPartF]
@[simp]
lemma anPart_position (φ : 𝓕.PositionStates) :
anPart (States.position φ) =
ofCrAnFieldOp ⟨States.position φ, CreateAnnihilate.annihilate⟩ := by
lemma anPart_position (φ : 𝓕.PositionFieldOp) :
anPart (FieldOp.position φ) =
ofCrAnFieldOp ⟨FieldOp.position φ, CreateAnnihilate.annihilate⟩ := by
simp [anPart, ofCrAnFieldOp]
@[simp]
lemma anPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPart (States.outAsymp φ) = ofCrAnFieldOp ⟨States.outAsymp φ, ()⟩ := by
anPart (FieldOp.outAsymp φ) = ofCrAnFieldOp ⟨FieldOp.outAsymp φ, ()⟩ := by
simp [anPart, ofCrAnFieldOp]
/-- The creation part of a state. -/
def crPart (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (crPartF φ)
def crPart (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (crPartF φ)
lemma crPart_eq_ι_crPartF (φ : 𝓕.States) : crPart φ = ι (crPartF φ) := rfl
lemma crPart_eq_ι_crPartF (φ : 𝓕.FieldOp) : crPart φ = ι (crPartF φ) := rfl
@[simp]
lemma crPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPart (States.inAsymp φ) = ofCrAnFieldOp ⟨States.inAsymp φ, ()⟩ := by
crPart (FieldOp.inAsymp φ) = ofCrAnFieldOp ⟨FieldOp.inAsymp φ, ()⟩ := by
simp [crPart, ofCrAnFieldOp]
@[simp]
lemma crPart_position (φ : 𝓕.PositionStates) :
crPart (States.position φ) =
ofCrAnFieldOp ⟨States.position φ, CreateAnnihilate.create⟩ := by
lemma crPart_position (φ : 𝓕.PositionFieldOp) :
crPart (FieldOp.position φ) =
ofCrAnFieldOp ⟨FieldOp.position φ, CreateAnnihilate.create⟩ := by
simp [crPart, ofCrAnFieldOp]
@[simp]
lemma crPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPart (States.outAsymp φ) = 0 := by
crPart (FieldOp.outAsymp φ) = 0 := by
simp [crPart]
lemma ofFieldOp_eq_crPart_add_anPart (φ : 𝓕.States) :
lemma ofFieldOp_eq_crPart_add_anPart (φ : 𝓕.FieldOp) :
ofFieldOp φ = crPart φ + anPart φ := by
rw [ofFieldOp, crPart, anPart, ofFieldOpF_eq_crPartF_add_anPartF]
simp only [map_add]

84
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/NormalOrder.lean
View file

@ -31,7 +31,7 @@ is zero.
-/
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnListF_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
(φa φa' : 𝓕.CrAnFieldOp) (φs φs' : List 𝓕.CrAnFieldOp) :
ι 𝓝ᶠ(ofCrAnListF φs * [ofCrAnOpF φa, ofCrAnOpF φa']ₛca * ofCrAnListF φs') = 0 := by
rcases CreateAnnihilate.eq_create_or_annihilate (𝓕 |>ᶜ φa) with hφa | hφa
<;> rcases CreateAnnihilate.eq_create_or_annihilate (𝓕 |>ᶜ φa') with hφa' | hφa'
@ -51,7 +51,7 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnListF_eq_zero
simp
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates)
(φa φa' : 𝓕.CrAnFieldOp) (φs : List 𝓕.CrAnFieldOp)
(a : 𝓕.FieldOpFreeAlgebra) : ι 𝓝ᶠ(ofCrAnListF φs * [ofCrAnOpF φa, ofCrAnOpF φa']ₛca * a) = 0 := by
have hf : ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap (ofCrAnListF φs * [ofCrAnOpF φa, ofCrAnOpF φa']ₛca) = 0 := by
@ -65,7 +65,7 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnListF_eq_zero
rw [hf]
simp
lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_eq_zero_mul (φa φa' : 𝓕.CrAnStates)
lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_eq_zero_mul (φa φa' : 𝓕.CrAnFieldOp)
(a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnOpF φa, ofCrAnOpF φa']ₛca * b) = 0 := by
rw [mul_assoc]
@ -83,8 +83,8 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_eq_zero_mul (φa φa' : 𝓕.CrAnS
rw [hf]
simp
lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_ofCrAnListF_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates)
lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_ofCrAnListF_eq_zero_mul (φa : 𝓕.CrAnFieldOp)
(φs : List 𝓕.CrAnFieldOp)
(a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnOpF φa, ofCrAnListF φs]ₛca * b) = 0 := by
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum]
@ -96,8 +96,8 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnOpF_ofCrAnListF_eq_zero_mul (φa :
rw [mul_assoc _ _ b, ofCrAnListF_singleton]
rw [ι_normalOrderF_superCommuteF_ofCrAnOpF_eq_zero_mul]
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnOpF_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) (a b : 𝓕.FieldOpFreeAlgebra) :
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnOpF_eq_zero_mul (φa : 𝓕.CrAnFieldOp)
(φs : List 𝓕.CrAnFieldOp) (a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnListF φs, ofCrAnOpF φa]ₛca * b) = 0 := by
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF_symm, ofCrAnListF_singleton]
simp only [FieldStatistic.instCommGroup.eq_1, FieldStatistic.ofList_singleton, mul_neg,
@ -106,7 +106,7 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnOpF_eq_zero_mul (φa :
simp
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnListF_eq_zero_mul
(φs φs' : List 𝓕.CrAnStates) (a b : 𝓕.FieldOpFreeAlgebra) :
(φs φs' : List 𝓕.CrAnFieldOp) (a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnListF φs, ofCrAnListF φs']ₛca * b) = 0 := by
rw [superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum, Finset.mul_sum, Finset.sum_mul]
rw [map_sum, map_sum]
@ -117,7 +117,7 @@ lemma ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnListF_eq_zero_mul
rw [ι_normalOrderF_superCommuteF_ofCrAnListF_ofCrAnOpF_eq_zero_mul]
lemma ι_normalOrderF_superCommuteF_ofCrAnListF_eq_zero_mul
(φs : List 𝓕.CrAnStates)
(φs : List 𝓕.CrAnFieldOp)
(a b c : 𝓕.FieldOpFreeAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnListF φs, c]ₛca * b) = 0 := by
change (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
@ -244,7 +244,7 @@ scoped[FieldSpecification.FieldOpAlgebra] notation "𝓝(" a ")" => normalOrder
lemma normalOrder_eq_ι_normalOrderF (a : 𝓕.FieldOpFreeAlgebra) :
𝓝(ι a) = ι 𝓝ᶠ(a) := rfl
lemma normalOrder_ofCrAnFieldOpList (φs : List 𝓕.CrAnStates) :
lemma normalOrder_ofCrAnFieldOpList (φs : List 𝓕.CrAnFieldOp) :
𝓝(ofCrAnFieldOpList φs) = normalOrderSign φs • ofCrAnFieldOpList (normalOrderList φs) := by
rw [ofCrAnFieldOpList, normalOrder_eq_ι_normalOrderF, normalOrderF_ofCrAnListF]
rfl
@ -256,7 +256,7 @@ lemma normalOrder_one_eq_one : normalOrder (𝓕 := 𝓕) 1 = 1 := by
rw [normalOrder_ofCrAnFieldOpList]
simp
lemma ofCrAnFieldOpList_eq_normalOrder (φs : List 𝓕.CrAnStates) :
lemma ofCrAnFieldOpList_eq_normalOrder (φs : List 𝓕.CrAnFieldOp) :
ofCrAnFieldOpList (normalOrderList φs) = normalOrderSign φs • 𝓝(ofCrAnFieldOpList φs) := by
rw [normalOrder_ofCrAnFieldOpList, smul_smul, normalOrderSign, Wick.koszulSign_mul_self,
one_smul]
@ -303,13 +303,13 @@ lemma normalOrder_normalOrder (a : 𝓕.FieldOpAlgebra) : 𝓝(𝓝(a)) = 𝓝(a
## mul anpart and crpart
-/
lemma normalOrder_mul_anPart (φ : 𝓕.States) (a : 𝓕.FieldOpAlgebra) :
lemma normalOrder_mul_anPart (φ : 𝓕.FieldOp) (a : 𝓕.FieldOpAlgebra) :
𝓝(a * anPart φ) = 𝓝(a) * anPart φ := by
obtain ⟨a, rfl⟩ := ι_surjective a
rw [anPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_mul_anPartF]
rfl
lemma crPart_mul_normalOrder (φ : 𝓕.States) (a : 𝓕.FieldOpAlgebra) :
lemma crPart_mul_normalOrder (φ : 𝓕.FieldOp) (a : 𝓕.FieldOpAlgebra) :
𝓝(crPart φ * a) = crPart φ * 𝓝(a) := by
obtain ⟨a, rfl⟩ := ι_surjective a
rw [crPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul]
@ -363,24 +363,24 @@ lemma normalOrder_superCommute_mid_eq_zero (a b c d : 𝓕.FieldOpAlgebra) :
-/
lemma normalOrder_ofFieldOp_ofFieldOp_swap (φ φ' : 𝓕.States) :
lemma normalOrder_ofFieldOp_ofFieldOp_swap (φ φ' : 𝓕.FieldOp) :
𝓝(ofFieldOp φ * ofFieldOp φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝(ofFieldOp φ' * ofFieldOp φ) := by
rw [ofFieldOp_mul_ofFieldOp_eq_superCommute]
simp
lemma normalOrder_ofCrAnFieldOp_ofCrAnFieldOpList (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) : 𝓝(ofCrAnFieldOp φ * ofCrAnFieldOpList φs) =
lemma normalOrder_ofCrAnFieldOp_ofCrAnFieldOpList (φ : 𝓕.CrAnFieldOp)
(φs : List 𝓕.CrAnFieldOp) : 𝓝(ofCrAnFieldOp φ * ofCrAnFieldOpList φs) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • 𝓝(ofCrAnFieldOpList φs * ofCrAnFieldOp φ) := by
rw [← ofCrAnFieldOpList_singleton, ofCrAnFieldOpList_mul_ofCrAnFieldOpList_eq_superCommute]
simp
lemma normalOrder_ofCrAnFieldOp_ofFieldOpList_swap (φ : 𝓕.CrAnStates) (φ' : List 𝓕.States) :
lemma normalOrder_ofCrAnFieldOp_ofFieldOpList_swap (φ : 𝓕.CrAnFieldOp) (φ' : List 𝓕.FieldOp) :
𝓝(ofCrAnFieldOp φ * ofFieldOpList φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓝(ofFieldOpList φ' * ofCrAnFieldOp φ) := by
rw [← ofCrAnFieldOpList_singleton, ofCrAnFieldOpList_mul_ofFieldOpList_eq_superCommute]
simp
lemma normalOrder_anPart_ofFieldOpList_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
lemma normalOrder_anPart_ofFieldOpList_swap (φ : 𝓕.FieldOp) (φ' : List 𝓕.FieldOp) :
𝓝(anPart φ * ofFieldOpList φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝(ofFieldOpList φ' * anPart φ) := by
match φ with
| .inAsymp φ =>
@ -394,18 +394,18 @@ lemma normalOrder_anPart_ofFieldOpList_swap (φ : 𝓕.States) (φ' : List 𝓕.
rw [normalOrder_ofCrAnFieldOp_ofFieldOpList_swap]
rfl
lemma normalOrder_ofFieldOpList_anPart_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
lemma normalOrder_ofFieldOpList_anPart_swap (φ : 𝓕.FieldOp) (φ' : List 𝓕.FieldOp) :
𝓝(ofFieldOpList φ' * anPart φ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝(anPart φ * ofFieldOpList φ') := by
rw [normalOrder_anPart_ofFieldOpList_swap]
simp [smul_smul, FieldStatistic.exchangeSign_mul_self]
lemma normalOrder_ofFieldOpList_mul_anPart_swap (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma normalOrder_ofFieldOpList_mul_anPart_swap (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
𝓝(ofFieldOpList φs) * anPart φ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • 𝓝(anPart φ * ofFieldOpList φs) := by
rw [← normalOrder_mul_anPart]
rw [normalOrder_ofFieldOpList_anPart_swap]
lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
(φs' : List 𝓕.States) : anPart φ * 𝓝(ofFieldOpList φs') =
lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.FieldOp)
(φs' : List 𝓕.FieldOp) : anPart φ * 𝓝(ofFieldOpList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝(ofFieldOpList φs' * anPart φ) +
[anPart φ, 𝓝(ofFieldOpList φs')]ₛ := by
rw [anPart, ofFieldOpList, normalOrder_eq_ι_normalOrderF, ← map_mul]
@ -419,8 +419,8 @@ lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
-/
lemma ofCrAnFieldOp_superCommute_normalOrder_ofCrAnFieldOpList_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) : [ofCrAnFieldOp φ, 𝓝(ofCrAnFieldOpList φs)]ₛ = ∑ n : Fin φs.length,
lemma ofCrAnFieldOp_superCommute_normalOrder_ofCrAnFieldOpList_sum (φ : 𝓕.CrAnFieldOp)
(φs : List 𝓕.CrAnFieldOp) : [ofCrAnFieldOp φ, 𝓝(ofCrAnFieldOpList φs)]ₛ = ∑ n : Fin φs.length,
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) • [ofCrAnFieldOp φ, ofCrAnFieldOp φs[n]]ₛ
* 𝓝(ofCrAnFieldOpList (φs.eraseIdx n)) := by
rw [normalOrder_ofCrAnFieldOpList, map_smul]
@ -445,8 +445,8 @@ lemma ofCrAnFieldOp_superCommute_normalOrder_ofCrAnFieldOpList_sum (φ : 𝓕.Cr
· erw [superCommute_diff_statistic hs]
simp
lemma ofCrAnFieldOp_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.States) :
lemma ofCrAnFieldOp_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.CrAnFieldOp)
(φs : List 𝓕.FieldOp) :
[ofCrAnFieldOp φ, 𝓝(ofFieldOpList φs)]ₛ = ∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
[ofCrAnFieldOp φ, ofFieldOp φs[n]]ₛ * 𝓝(ofFieldOpList (φs.eraseIdx n)) := by
conv_lhs =>
@ -471,7 +471,7 @@ Within a proto-operator algebra we have that
`[anPartF φ, 𝓝(φs)] = ∑ i, sᵢ • [anPartF φ, φᵢ]ₛ * 𝓝(φ₀…φᵢ₋₁φᵢ₊₁…φₙ)`
where `sᵢ` is the exchange sign for `φ` and `φ₀…φᵢ₋₁`.
-/
lemma anPart_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma anPart_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[anPart φ, 𝓝(ofFieldOpList φs)]ₛ = ∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
[anPart φ, ofFieldOpF φs[n]]ₛ * 𝓝(ofFieldOpList (φs.eraseIdx n)) := by
match φ with
@ -480,13 +480,13 @@ lemma anPart_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.States) (φs
| .position φ =>
simp only [anPart_position, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
rw [ofCrAnFieldOp_superCommute_normalOrder_ofFieldOpList_sum]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod,
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod,
Fin.getElem_fin, Algebra.smul_mul_assoc]
rfl
| .outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
rw [ofCrAnFieldOp_superCommute_normalOrder_ofFieldOpList_sum]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod,
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod,
Fin.getElem_fin, Algebra.smul_mul_assoc]
rfl
@ -499,8 +499,8 @@ lemma anPart_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.States) (φs
Within a proto-operator algebra we have that
`anPartF φ * 𝓝(φ₀φ₁…φₙ) = 𝓝((anPart φ)φ₀φ₁…φₙ) + [anpart φ, 𝓝(φ₀φ₁…φₙ)]ₛ`.
-/
lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute_reorder (φ : 𝓕.States)
(φs : List 𝓕.States) : anPart φ * 𝓝(ofFieldOpList φs) =
lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute_reorder (φ : 𝓕.FieldOp)
(φs : List 𝓕.FieldOp) : anPart φ * 𝓝(ofFieldOpList φs) =
𝓝(anPart φ * ofFieldOpList φs) + [anPart φ, 𝓝(ofFieldOpList φs)]ₛ := by
rw [anPart_mul_normalOrder_ofFieldOpList_eq_superCommute]
simp only [instCommGroup.eq_1, add_left_inj]
@ -510,8 +510,8 @@ lemma anPart_mul_normalOrder_ofFieldOpList_eq_superCommute_reorder (φ : 𝓕.St
Within a proto-operator algebra we have that
`φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ(φφ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
-/
lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
(φs : List 𝓕.States) : ofFieldOp φ * 𝓝(ofFieldOpList φs) =
lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.FieldOp)
(φs : List 𝓕.FieldOp) : ofFieldOp φ * 𝓝(ofFieldOpList φs) =
𝓝(ofFieldOp φ * ofFieldOpList φs) + [anPart φ, 𝓝(ofFieldOpList φs)]ₛ := by
conv_lhs => rw [ofFieldOp_eq_crPart_add_anPart]
rw [add_mul, anPart_mul_normalOrder_ofFieldOpList_eq_superCommute_reorder, ← add_assoc,
@ -522,7 +522,7 @@ lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
/-- In the expansion of `ofFieldOpF φ * normalOrderF (ofFieldOpListF φs)` the element
of `𝓞.A` associated with contracting `φ` with the (optional) `n`th element of `φs`. -/
noncomputable def contractStateAtIndex (φ : 𝓕.States) (φs : List 𝓕.States)
noncomputable def contractStateAtIndex (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(n : Option (Fin φs.length)) : 𝓕.FieldOpAlgebra :=
match n with
| none => 1
@ -533,8 +533,8 @@ Within a proto-operator algebra,
`φ * N(φ₀φ₁…φₙ) = N(φφ₀φ₁…φₙ) + ∑ i, (sᵢ • [anPartF φ, φᵢ]ₛ) * N(φ₀φ₁…φᵢ₋₁φᵢ₊₁…φₙ)`,
where `sₙ` is the exchange sign for `φ` and `φ₀φ₁…φᵢ₋₁`.
-/
lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum (φ : 𝓕.States)
(φs : List 𝓕.States) : ofFieldOp φ * 𝓝(ofFieldOpList φs) =
lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum (φ : 𝓕.FieldOp)
(φs : List 𝓕.FieldOp) : ofFieldOp φ * 𝓝(ofFieldOpList φs) =
∑ n : Option (Fin φs.length), contractStateAtIndex φ φs n *
𝓝(ofFieldOpList (HepLean.List.optionEraseZ φs φ n)) := by
rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute]
@ -553,7 +553,7 @@ lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum (φ : 𝓕.States)
Within a proto-operator algebra, `N(φφ₀φ₁…φₙ) = s • N(φ₀…φₖ₋₁φφₖ…φₙ)`, where
`s` is the exchange sign for `φ` and `φ₀…φₖ₋₁`.
-/
lemma ofFieldOpList_normalOrder_insert (φ : 𝓕.States) (φs : List 𝓕.States)
lemma ofFieldOpList_normalOrder_insert (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(k : Fin φs.length.succ) : 𝓝(ofFieldOpList (φ :: φs)) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs.take k) • 𝓝(ofFieldOpList (φs.insertIdx k φ)) := by
have hl : φs.insertIdx k φ = φs.take k ++ [φ] ++ φs.drop k := by
@ -575,27 +575,27 @@ lemma ofFieldOpList_normalOrder_insert (φ : 𝓕.States) (φs : List 𝓕.State
-/
@[simp]
lemma normalOrder_crPart_mul_crPart (φ φ' : 𝓕.States) :
lemma normalOrder_crPart_mul_crPart (φ φ' : 𝓕.FieldOp) :
𝓝(crPart φ * crPart φ') = crPart φ * crPart φ' := by
rw [crPart, crPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul_crPartF]
@[simp]
lemma normalOrder_anPart_mul_anPart (φ φ' : 𝓕.States) :
lemma normalOrder_anPart_mul_anPart (φ φ' : 𝓕.FieldOp) :
𝓝(anPart φ * anPart φ') = anPart φ * anPart φ' := by
rw [anPart, anPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_anPartF_mul_anPartF]
@[simp]
lemma normalOrder_crPart_mul_anPart (φ φ' : 𝓕.States) :
lemma normalOrder_crPart_mul_anPart (φ φ' : 𝓕.FieldOp) :
𝓝(crPart φ * anPart φ') = crPart φ * anPart φ' := by
rw [crPart, anPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul_anPartF]
@[simp]
lemma normalOrder_anPart_mul_crPart (φ φ' : 𝓕.States) :
lemma normalOrder_anPart_mul_crPart (φ φ' : 𝓕.FieldOp) :
𝓝(anPart φ * crPart φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ := by
rw [anPart, crPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_anPartF_mul_crPartF]
simp
lemma normalOrder_ofFieldOp_mul_ofFieldOp (φ φ' : 𝓕.States) : 𝓝(ofFieldOp φ * ofFieldOp φ') =
lemma normalOrder_ofFieldOp_mul_ofFieldOp (φ φ' : 𝓕.FieldOp) : 𝓝(ofFieldOp φ * ofFieldOp φ') =
crPart φ * crPart φ' + 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • (crPart φ' * anPart φ) +
crPart φ * anPart φ' + anPart φ * anPart φ' := by
rw [ofFieldOp, ofFieldOp, ← map_mul, normalOrder_eq_ι_normalOrderF,

10
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/StaticWickTheorem.lean
View file

@ -35,7 +35,7 @@ over all Wick contraction `φsΛ`.
This is compared to the ordinary Wicks theorem in which `staticContract` is replaced with
`timeContract`.
-/
theorem static_wick_theorem : (φs : List 𝓕.States) →
theorem static_wick_theorem : (φs : List 𝓕.FieldOp) →
ofFieldOpList φs = ∑ (φsΛ : WickContraction φs.length),
φsΛ.sign • φsΛ.staticContract * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)
| [] => static_wick_theorem_nil
@ -54,11 +54,11 @@ theorem static_wick_theorem : (φs : List 𝓕.States) →
simp [mul_assoc]
rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum]
rw [Finset.mul_sum]
rw [uncontractedStatesEquiv_list_sum]
rw [uncontractedFieldOpEquiv_list_sum]
refine Finset.sum_congr rfl (fun n _ => ?_)
match n with
| none =>
simp only [contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply,
Equiv.coe_trans, Option.map_none', one_mul, Algebra.smul_mul_assoc, Nat.succ_eq_add_one,
Fin.zero_eta, Fin.val_zero, List.insertIdx_zero, staticContract_insertAndContract_none,
insertAndContract_uncontractedList_none_zero]
@ -96,8 +96,8 @@ theorem static_wick_theorem : (φs : List 𝓕.States) →
exact h0
· simp_all only [Finset.mem_univ, not_not, instCommGroup.eq_1, forall_const]
have h1 : contractStateAtIndex φ [c]ᵘᶜ
((uncontractedStatesEquiv φs c) (some n)) = 0 := by
simp only [contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
((uncontractedFieldOpEquiv φs c) (some n)) = 0 := by
simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply,
Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply,
instCommGroup.eq_1, Fin.coe_cast, Fin.getElem_fin, smul_eq_zero]
right

128
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/SuperCommute.lean
View file

@ -129,24 +129,24 @@ lemma superCommute_eq_ι_superCommuteF (a b : 𝓕.FieldOpFreeAlgebra) :
-/
lemma superCommute_create_create {φ φ' : 𝓕.CrAnStates}
lemma superCommute_create_create {φ φ' : 𝓕.CrAnFieldOp}
(h : 𝓕 |>ᶜ φ = .create) (h' : 𝓕 |>ᶜ φ' = .create) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = 0 := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
rw [superCommute_eq_ι_superCommuteF, ι_superCommuteF_of_create_create _ _ h h']
lemma superCommute_annihilate_annihilate {φ φ' : 𝓕.CrAnStates}
lemma superCommute_annihilate_annihilate {φ φ' : 𝓕.CrAnFieldOp}
(h : 𝓕 |>ᶜ φ = .annihilate) (h' : 𝓕 |>ᶜ φ' = .annihilate) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = 0 := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
rw [superCommute_eq_ι_superCommuteF, ι_superCommuteF_of_annihilate_annihilate _ _ h h']
lemma superCommute_diff_statistic {φ φ' : 𝓕.CrAnStates} (h : (𝓕 |>ₛ φ) ≠ 𝓕 |>ₛ φ') :
lemma superCommute_diff_statistic {φ φ' : 𝓕.CrAnFieldOp} (h : (𝓕 |>ₛ φ) ≠ 𝓕 |>ₛ φ') :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = 0 := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
rw [superCommute_eq_ι_superCommuteF, ι_superCommuteF_of_diff_statistic h]
lemma superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero (φ : 𝓕.CrAnStates) (ψ : 𝓕.States)
lemma superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero (φ : 𝓕.CrAnFieldOp) (ψ : 𝓕.FieldOp)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : [ofCrAnFieldOp φ, ofFieldOp ψ]ₛ = 0 := by
rw [ofFieldOp_eq_sum, map_sum]
rw [Finset.sum_eq_zero]
@ -154,33 +154,33 @@ lemma superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero (φ : 𝓕.CrAnStates)
apply superCommute_diff_statistic
simpa [crAnStatistics] using h
lemma superCommute_anPart_ofFieldOpF_diff_grade_zero (φ ψ : 𝓕.States)
lemma superCommute_anPart_ofFieldOpF_diff_grade_zero (φ ψ : 𝓕.FieldOp)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : [anPart φ, ofFieldOp ψ]ₛ = 0 := by
match φ with
| States.inAsymp _ =>
| FieldOp.inAsymp _ =>
simp
| States.position φ =>
| FieldOp.position φ =>
simp only [anPartF_position]
apply superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero _ _ _
simpa [crAnStatistics] using h
| States.outAsymp _ =>
| FieldOp.outAsymp _ =>
simp only [anPartF_posAsymp]
apply superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero _ _
simpa [crAnStatistics] using h
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center (φ φ' : 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
rw [ofCrAnFieldOp, ofCrAnFieldOp, superCommute_eq_ι_superCommuteF]
exact ι_superCommuteF_ofCrAnOpF_ofCrAnOpF_mem_center φ φ'
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_commute (φ φ' : 𝓕.CrAnStates)
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_commute (φ φ' : 𝓕.CrAnFieldOp)
(a : FieldOpAlgebra 𝓕) :
a * [ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = [ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ * a := by
have h1 := superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center φ φ'
rw [@Subalgebra.mem_center_iff] at h1
exact h1 a
lemma superCommute_ofCrAnFieldOp_ofFieldOp_mem_center (φ : 𝓕.CrAnStates) (φ' : 𝓕.States) :
lemma superCommute_ofCrAnFieldOp_ofFieldOp_mem_center (φ : 𝓕.CrAnFieldOp) (φ' : 𝓕.FieldOp) :
[ofCrAnFieldOp φ, ofFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
rw [ofFieldOp_eq_sum]
simp only [map_sum]
@ -188,22 +188,22 @@ lemma superCommute_ofCrAnFieldOp_ofFieldOp_mem_center (φ : 𝓕.CrAnStates) (φ
intro x hx
exact superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center φ ⟨φ', x⟩
lemma superCommute_ofCrAnFieldOp_ofFieldOp_commute (φ : 𝓕.CrAnStates) (φ' : 𝓕.States)
lemma superCommute_ofCrAnFieldOp_ofFieldOp_commute (φ : 𝓕.CrAnFieldOp) (φ' : 𝓕.FieldOp)
(a : FieldOpAlgebra 𝓕) : a * [ofCrAnFieldOp φ, ofFieldOp φ']ₛ =
[ofCrAnFieldOp φ, ofFieldOp φ']ₛ * a := by
have h1 := superCommute_ofCrAnFieldOp_ofFieldOp_mem_center φ φ'
rw [@Subalgebra.mem_center_iff] at h1
exact h1 a
lemma superCommute_anPart_ofFieldOp_mem_center (φ φ' : 𝓕.States) :
lemma superCommute_anPart_ofFieldOp_mem_center (φ φ' : 𝓕.FieldOp) :
[anPart φ, ofFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
match φ with
| States.inAsymp _ =>
| FieldOp.inAsymp _ =>
simp only [anPart_negAsymp, map_zero, LinearMap.zero_apply]
exact Subalgebra.zero_mem (Subalgebra.center ℂ _)
| States.position φ =>
| FieldOp.position φ =>
exact superCommute_ofCrAnFieldOp_ofFieldOp_mem_center _ _
| States.outAsymp _ =>
| FieldOp.outAsymp _ =>
exact superCommute_ofCrAnFieldOp_ofFieldOp_mem_center _ _
/-!
@ -212,57 +212,57 @@ lemma superCommute_anPart_ofFieldOp_mem_center (φ φ' : 𝓕.States) :
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList (φs φs' : List 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
ofCrAnFieldOpList (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnFieldOpList (φs' ++ φs) := by
rw [ofCrAnFieldOpList_eq_ι_ofCrAnListF, ofCrAnFieldOpList_eq_ι_ofCrAnListF]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnListF_ofCrAnListF]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp (φ φ' : 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = ofCrAnFieldOp φ * ofCrAnFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofCrAnFieldOp φ' * ofCrAnFieldOp φ := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnOpF_ofCrAnOpF]
rfl
lemma superCommute_ofCrAnFieldOpList_ofFieldOpList (φcas : List 𝓕.CrAnStates)
(φs : List 𝓕.States) :
lemma superCommute_ofCrAnFieldOpList_ofFieldOpList (φcas : List 𝓕.CrAnFieldOp)
(φs : List 𝓕.FieldOp) :
[ofCrAnFieldOpList φcas, ofFieldOpList φs]ₛ = ofCrAnFieldOpList φcas * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofFieldOpList φs * ofCrAnFieldOpList φcas := by
rw [ofCrAnFieldOpList, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnListF_ofFieldOpFsList]
rfl
lemma superCommute_ofFieldOpList_ofFieldOpList (φs φs' : List 𝓕.States) :
lemma superCommute_ofFieldOpList_ofFieldOpList (φs φs' : List 𝓕.FieldOp) :
[ofFieldOpList φs, ofFieldOpList φs']ₛ = ofFieldOpList φs * ofFieldOpList φs' -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofFieldOpListF_ofFieldOpFsList]
rfl
lemma superCommute_ofFieldOp_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommute_ofFieldOp_ofFieldOpList (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[ofFieldOp φ, ofFieldOpList φs]ₛ = ofFieldOp φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * ofFieldOp φ := by
rw [ofFieldOp, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofFieldOpF_ofFieldOpFsList]
rfl
lemma superCommute_ofFieldOpList_ofFieldOp (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma superCommute_ofFieldOpList_ofFieldOp (φs : List 𝓕.FieldOp) (φ : 𝓕.FieldOp) :
[ofFieldOpList φs, ofFieldOp φ]ₛ = ofFieldOpList φs * ofFieldOp φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOp φ * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofFieldOpListF_ofFieldOpF]
rfl
lemma superCommute_anPart_crPart (φ φ' : 𝓕.States) :
lemma superCommute_anPart_crPart (φ φ' : 𝓕.FieldOp) :
[anPart φ, crPart φ']ₛ = anPart φ * crPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ := by
rw [anPart, crPart]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_crPartF]
rfl
lemma superCommute_crPart_anPart (φ φ' : 𝓕.States) :
lemma superCommute_crPart_anPart (φ φ' : 𝓕.FieldOp) :
[crPart φ, anPart φ']ₛ = crPart φ * anPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * crPart φ := by
rw [anPart, crPart]
@ -270,83 +270,83 @@ lemma superCommute_crPart_anPart (φ φ' : 𝓕.States) :
rfl
@[simp]
lemma superCommute_crPart_crPart (φ φ' : 𝓕.States) : [crPart φ, crPart φ']ₛ = 0 := by
lemma superCommute_crPart_crPart (φ φ' : 𝓕.FieldOp) : [crPart φ, crPart φ']ₛ = 0 := by
match φ, φ' with
| States.outAsymp φ, _ =>
| FieldOp.outAsymp φ, _ =>
simp
| _, States.outAsymp φ =>
| _, FieldOp.outAsymp φ =>
simp
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [crPart_position]
apply superCommute_create_create
· rfl
· rfl
| States.position φ, States.inAsymp φ' =>
| FieldOp.position φ, FieldOp.inAsymp φ' =>
simp only [crPart_position, crPart_negAsymp]
apply superCommute_create_create
· rfl
· rfl
| States.inAsymp φ, States.inAsymp φ' =>
| FieldOp.inAsymp φ, FieldOp.inAsymp φ' =>
simp only [crPart_negAsymp]
apply superCommute_create_create
· rfl
· rfl
| States.inAsymp φ, States.position φ' =>
| FieldOp.inAsymp φ, FieldOp.position φ' =>
simp only [crPart_negAsymp, crPart_position]
apply superCommute_create_create
· rfl
· rfl
@[simp]
lemma superCommute_anPart_anPart (φ φ' : 𝓕.States) : [anPart φ, anPart φ']ₛ = 0 := by
lemma superCommute_anPart_anPart (φ φ' : 𝓕.FieldOp) : [anPart φ, anPart φ']ₛ = 0 := by
match φ, φ' with
| States.inAsymp φ, _ =>
| FieldOp.inAsymp φ, _ =>
simp
| _, States.inAsymp φ =>
| _, FieldOp.inAsymp φ =>
simp
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [anPart_position]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.position φ, States.outAsymp φ' =>
| FieldOp.position φ, FieldOp.outAsymp φ' =>
simp only [anPart_position, anPart_posAsymp]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.outAsymp φ, States.outAsymp φ' =>
| FieldOp.outAsymp φ, FieldOp.outAsymp φ' =>
simp only [anPart_posAsymp]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.outAsymp φ, States.position φ' =>
| FieldOp.outAsymp φ, FieldOp.position φ' =>
simp only [anPart_posAsymp, anPart_position]
apply superCommute_annihilate_annihilate
· rfl
· rfl
lemma superCommute_crPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommute_crPart_ofFieldOpList (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[crPart φ, ofFieldOpList φs]ₛ = crPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * crPart φ := by
rw [crPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofFieldOpListF]
rfl
lemma superCommute_anPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommute_anPart_ofFieldOpList (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[anPart φ, ofFieldOpList φs]ₛ = anPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * anPart φ := by
rw [anPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_ofFieldOpListF]
rfl
lemma superCommute_crPart_ofFieldOp (φ φ' : 𝓕.States) :
lemma superCommute_crPart_ofFieldOp (φ φ' : 𝓕.FieldOp) :
[crPart φ, ofFieldOp φ']ₛ = crPart φ * ofFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOp φ' * crPart φ := by
rw [crPart, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofFieldOpF]
rfl
lemma superCommute_anPart_ofFieldOp (φ φ' : 𝓕.States) :
lemma superCommute_anPart_ofFieldOp (φ φ' : 𝓕.FieldOp) :
[anPart φ, ofFieldOp φ']ₛ = anPart φ * ofFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOp φ' * anPart φ := by
rw [anPart, ofFieldOp]
@ -362,73 +362,73 @@ multiplication with a sign plus the super commutor.
-/
lemma ofCrAnFieldOpList_mul_ofCrAnFieldOpList_eq_superCommute (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnFieldOpList_mul_ofCrAnFieldOpList_eq_superCommute (φs φs' : List 𝓕.CrAnFieldOp) :
ofCrAnFieldOpList φs * ofCrAnFieldOpList φs' =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnFieldOpList φs' * ofCrAnFieldOpList φs
+ [ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ := by
rw [superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList]
simp [ofCrAnFieldOpList_append]
lemma ofCrAnFieldOp_mul_ofCrAnFieldOpList_eq_superCommute (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.CrAnStates) : ofCrAnFieldOp φ * ofCrAnFieldOpList φs' =
lemma ofCrAnFieldOp_mul_ofCrAnFieldOpList_eq_superCommute (φ : 𝓕.CrAnFieldOp)
(φs' : List 𝓕.CrAnFieldOp) : ofCrAnFieldOp φ * ofCrAnFieldOpList φs' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofCrAnFieldOpList φs' * ofCrAnFieldOp φ
+ [ofCrAnFieldOp φ, ofCrAnFieldOpList φs']ₛ := by
rw [← ofCrAnFieldOpList_singleton, ofCrAnFieldOpList_mul_ofCrAnFieldOpList_eq_superCommute]
simp
lemma ofFieldOpList_mul_ofFieldOpList_eq_superCommute (φs φs' : List 𝓕.States) :
lemma ofFieldOpList_mul_ofFieldOpList_eq_superCommute (φs φs' : List 𝓕.FieldOp) :
ofFieldOpList φs * ofFieldOpList φs' =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOpList φs
+ [ofFieldOpList φs, ofFieldOpList φs']ₛ := by
rw [superCommute_ofFieldOpList_ofFieldOpList]
simp
lemma ofFieldOp_mul_ofFieldOpList_eq_superCommute (φ : 𝓕.States) (φs' : List 𝓕.States) :
lemma ofFieldOp_mul_ofFieldOpList_eq_superCommute (φ : 𝓕.FieldOp) (φs' : List 𝓕.FieldOp) :
ofFieldOp φ * ofFieldOpList φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOp φ
+ [ofFieldOp φ, ofFieldOpList φs']ₛ := by
rw [superCommute_ofFieldOp_ofFieldOpList]
simp
lemma ofFieldOp_mul_ofFieldOp_eq_superCommute (φ φ' : 𝓕.States) :
lemma ofFieldOp_mul_ofFieldOp_eq_superCommute (φ φ' : 𝓕.FieldOp) :
ofFieldOp φ * ofFieldOp φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOp φ' * ofFieldOp φ
+ [ofFieldOp φ, ofFieldOp φ']ₛ := by
rw [← ofFieldOpList_singleton, ← ofFieldOpList_singleton]
rw [ofFieldOpList_mul_ofFieldOpList_eq_superCommute, ofFieldOpList_singleton]
simp
lemma ofFieldOpList_mul_ofFieldOp_eq_superCommute (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma ofFieldOpList_mul_ofFieldOp_eq_superCommute (φs : List 𝓕.FieldOp) (φ : 𝓕.FieldOp) :
ofFieldOpList φs * ofFieldOp φ = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOp φ * ofFieldOpList φs
+ [ofFieldOpList φs, ofFieldOp φ]ₛ := by
rw [superCommute_ofFieldOpList_ofFieldOp]
simp
lemma ofCrAnFieldOpList_mul_ofFieldOpList_eq_superCommute (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : ofCrAnFieldOpList φs * ofFieldOpList φs' =
lemma ofCrAnFieldOpList_mul_ofFieldOpList_eq_superCommute (φs : List 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) : ofCrAnFieldOpList φs * ofFieldOpList φs' =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofCrAnFieldOpList φs
+ [ofCrAnFieldOpList φs, ofFieldOpList φs']ₛ := by
rw [superCommute_ofCrAnFieldOpList_ofFieldOpList]
simp
lemma crPart_mul_anPart_eq_superCommute (φ φ' : 𝓕.States) :
lemma crPart_mul_anPart_eq_superCommute (φ φ' : 𝓕.FieldOp) :
crPart φ * anPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * crPart φ
+ [crPart φ, anPart φ']ₛ := by
rw [superCommute_crPart_anPart]
simp
lemma anPart_mul_crPart_eq_superCommute (φ φ' : 𝓕.States) :
lemma anPart_mul_crPart_eq_superCommute (φ φ' : 𝓕.FieldOp) :
anPart φ * crPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ
+ [anPart φ, crPart φ']ₛ := by
rw [superCommute_anPart_crPart]
simp
lemma crPart_mul_crPart_swap (φ φ' : 𝓕.States) :
lemma crPart_mul_crPart_swap (φ φ' : 𝓕.FieldOp) :
crPart φ * crPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * crPart φ := by
trans 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * crPart φ + [crPart φ, crPart φ']ₛ
· rw [crPart, crPart, superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_crPartF]
simp
· simp
lemma anPart_mul_anPart_swap (φ φ' : 𝓕.States) :
lemma anPart_mul_anPart_swap (φ φ' : 𝓕.FieldOp) :
anPart φ * anPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * anPart φ := by
trans 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * anPart φ + [anPart φ, anPart φ']ₛ
· rw [anPart, anPart, superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_anPartF]
@ -441,14 +441,14 @@ lemma anPart_mul_anPart_swap (φ φ' : 𝓕.States) :
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_symm (φs φs' : List 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_symm (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
(- 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs')) • [ofCrAnFieldOpList φs', ofCrAnFieldOpList φs]ₛ := by
rw [ofCrAnFieldOpList, ofCrAnFieldOpList, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnListF_ofCrAnListF_symm]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_symm (φ φ' : 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_symm (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ =
(- 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ')) • [ofCrAnFieldOp φ', ofCrAnFieldOp φ]ₛ := by
rw [ofCrAnFieldOp, ofCrAnFieldOp, superCommute_eq_ι_superCommuteF,
@ -461,7 +461,7 @@ lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_symm (φ φ' : 𝓕.CrAnStates) :
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum (φs φs' : List 𝓕.CrAnStates) :
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofCrAnFieldOpList (φs'.take n) * [ofCrAnFieldOpList φs, ofCrAnFieldOp (φs'.get n)]ₛ *
@ -472,8 +472,8 @@ lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum (φs φs' : List
rw [map_sum]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.CrAnStates) : [ofCrAnFieldOp φ, ofCrAnFieldOpList φs']ₛ =
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum (φ : 𝓕.CrAnFieldOp)
(φs' : List 𝓕.CrAnFieldOp) : [ofCrAnFieldOp φ, ofCrAnFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs'.take n) •
[ofCrAnFieldOp φ, ofCrAnFieldOp (φs'.get n)]ₛ * ofCrAnFieldOpList (φs'.eraseIdx n) := by
conv_lhs =>
@ -487,8 +487,8 @@ lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum (φ : 𝓕.CrAnStates)
congr
exact Eq.symm (List.eraseIdx_eq_take_drop_succ φs' ↑n)
lemma superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnFieldOpList φs, ofFieldOpList φs']ₛ =
lemma superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum (φs : List 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) : [ofCrAnFieldOpList φs, ofFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofFieldOpList (φs'.take n) * [ofCrAnFieldOpList φs, ofFieldOp (φs'.get n)]ₛ *
ofFieldOpList (φs'.drop (n + 1)) := by
@ -498,7 +498,7 @@ lemma superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum (φs : List 𝓕.CrAnS
rw [map_sum]
rfl
lemma superCommute_ofCrAnFieldOp_ofFieldOpList_eq_sum (φ : 𝓕.CrAnStates) (φs' : List 𝓕.States) :
lemma superCommute_ofCrAnFieldOp_ofFieldOpList_eq_sum (φ : 𝓕.CrAnFieldOp) (φs' : List 𝓕.FieldOp) :
[ofCrAnFieldOp φ, ofFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs'.take n) •
[ofCrAnFieldOp φ, ofFieldOp (φs'.get n)]ₛ * ofFieldOpList (φs'.eraseIdx n) := by

24
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/TimeContraction.lean
View file

@ -23,16 +23,16 @@ namespace FieldOpAlgebra
open FieldStatistic
/-- The time contraction of two States as an element of `𝓞.A` defined
/-- The time contraction of two FieldOp as an element of `𝓞.A` defined
as their time ordering in the state algebra minus their normal ordering in the
creation and annihlation algebra, both mapped to `𝓞.A`.. -/
def timeContract (φ ψ : 𝓕.States) : 𝓕.FieldOpAlgebra :=
def timeContract (φ ψ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra :=
𝓣(ofFieldOp φ * ofFieldOp ψ) - 𝓝(ofFieldOp φ * ofFieldOp ψ)
lemma timeContract_eq_smul (φ ψ : 𝓕.States) : timeContract φ ψ =
lemma timeContract_eq_smul (φ ψ : 𝓕.FieldOp) : timeContract φ ψ =
𝓣(ofFieldOp φ * ofFieldOp ψ) + (-1 : ℂ) • 𝓝(ofFieldOp φ * ofFieldOp ψ) := by rfl
lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.States) (h : timeOrderRel φ ψ) :
lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.FieldOp) (h : timeOrderRel φ ψ) :
timeContract φ ψ = [anPart φ, ofFieldOp ψ]ₛ := by
conv_rhs =>
rw [ofFieldOp_eq_crPart_add_anPart]
@ -45,7 +45,7 @@ lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.States) (h : timeOrderRel φ ψ
simp only [mul_add, add_mul]
abel_nf
lemma timeContract_of_not_timeOrderRel (φ ψ : 𝓕.States) (h : ¬ timeOrderRel φ ψ) :
lemma timeContract_of_not_timeOrderRel (φ ψ : 𝓕.FieldOp) (h : ¬ timeOrderRel φ ψ) :
timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • timeContract ψ φ := by
rw [timeContract_eq_smul]
simp only [Int.reduceNeg, one_smul, map_add]
@ -55,14 +55,14 @@ lemma timeContract_of_not_timeOrderRel (φ ψ : 𝓕.States) (h : ¬ timeOrderRe
simp only [instCommGroup.eq_1, map_smul, map_add, smul_add]
rw [smul_smul, smul_smul, mul_comm]
lemma timeContract_of_not_timeOrderRel_expand (φ ψ : 𝓕.States) (h : ¬ timeOrderRel φ ψ) :
lemma timeContract_of_not_timeOrderRel_expand (φ ψ : 𝓕.FieldOp) (h : ¬ timeOrderRel φ ψ) :
timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • [anPart ψ, ofFieldOp φ]ₛ := by
rw [timeContract_of_not_timeOrderRel _ _ h]
rw [timeContract_of_timeOrderRel _ _ _]
have h1 := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
lemma timeContract_mem_center (φ ψ : 𝓕.States) :
lemma timeContract_mem_center (φ ψ : 𝓕.FieldOp) :
timeContract φ ψ ∈ Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
by_cases h : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ h]
@ -74,7 +74,7 @@ lemma timeContract_mem_center (φ ψ : 𝓕.States) :
have h1 := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
lemma timeContract_zero_of_diff_grade (φ ψ : 𝓕.States) (h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
lemma timeContract_zero_of_diff_grade (φ ψ : 𝓕.FieldOp) (h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
timeContract φ ψ = 0 := by
by_cases h1 : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ h1]
@ -88,7 +88,7 @@ lemma timeContract_zero_of_diff_grade (φ ψ : 𝓕.States) (h : (𝓕 |>ₛ φ)
have ht := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
lemma normalOrder_timeContract (φ ψ : 𝓕.States) :
lemma normalOrder_timeContract (φ ψ : 𝓕.FieldOp) :
𝓝(timeContract φ ψ) = 0 := by
by_cases h : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ h]
@ -101,7 +101,7 @@ lemma normalOrder_timeContract (φ ψ : 𝓕.States) :
rw [timeContract_of_timeOrderRel _ _ h1]
simp
lemma timeOrder_timeContract_eq_time_mid {φ ψ : 𝓕.States}
lemma timeOrder_timeContract_eq_time_mid {φ ψ : 𝓕.FieldOp}
(h1 : timeOrderRel φ ψ) (h2 : timeOrderRel ψ φ) (a b : 𝓕.FieldOpAlgebra) :
𝓣(a * timeContract φ ψ * b) = timeContract φ ψ * 𝓣(a * b) := by
rw [timeContract_of_timeOrderRel _ _ h1]
@ -123,7 +123,7 @@ lemma timeOrder_timeContract_eq_time_mid {φ ψ : 𝓕.States}
simp only [crAnTimeOrderRel, h1]
simp [crAnTimeOrderRel, h2]
lemma timeOrder_timeContract_eq_time_left {φ ψ : 𝓕.States}
lemma timeOrder_timeContract_eq_time_left {φ ψ : 𝓕.FieldOp}
(h1 : timeOrderRel φ ψ) (h2 : timeOrderRel ψ φ) (b : 𝓕.FieldOpAlgebra) :
𝓣(timeContract φ ψ * b) = timeContract φ ψ * 𝓣(b) := by
trans 𝓣(1 * timeContract φ ψ * b)
@ -131,7 +131,7 @@ lemma timeOrder_timeContract_eq_time_left {φ ψ : 𝓕.States}
rw [timeOrder_timeContract_eq_time_mid h1 h2]
simp
lemma timeOrder_timeContract_neq_time {φ ψ : 𝓕.States}
lemma timeOrder_timeContract_neq_time {φ ψ : 𝓕.FieldOp}
(h1 : ¬ (timeOrderRel φ ψ ∧ timeOrderRel ψ φ)) :
𝓣(timeContract φ ψ) = 0 := by
by_cases h2 : timeOrderRel φ ψ

32
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/TimeOrder.lean
View file

@ -19,8 +19,8 @@ open FieldStatistic
namespace FieldOpAlgebra
variable {𝓕 : FieldSpecification}
lemma ι_timeOrderF_superCommuteF_superCommuteF_eq_time_ofCrAnListF {φ1 φ2 φ3 : 𝓕.CrAnStates}
(φs1 φs2 : List 𝓕.CrAnStates) (h :
lemma ι_timeOrderF_superCommuteF_superCommuteF_eq_time_ofCrAnListF {φ1 φ2 φ3 : 𝓕.CrAnFieldOp}
(φs1 φs2 : List 𝓕.CrAnFieldOp) (h :
crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
crAnTimeOrderRel φ3 φ1 ∧ crAnTimeOrderRel φ3 φ2) :
@ -139,8 +139,8 @@ lemma ι_timeOrderF_superCommuteF_superCommuteF_eq_time_ofCrAnListF {φ1 φ2 φ3
map_smul, smul_sub]
simp_all
lemma ι_timeOrderF_superCommuteF_superCommuteF_ofCrAnListF {φ1 φ2 φ3 : 𝓕.CrAnStates}
(φs1 φs2 : List 𝓕.CrAnStates) :
lemma ι_timeOrderF_superCommuteF_superCommuteF_ofCrAnListF {φ1 φ2 φ3 : 𝓕.CrAnFieldOp}
(φs1 φs2 : List 𝓕.CrAnFieldOp) :
ι 𝓣ᶠ(ofCrAnListF φs1 * [ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca * ofCrAnListF φs2)
= 0 := by
by_cases h :
@ -153,7 +153,7 @@ lemma ι_timeOrderF_superCommuteF_superCommuteF_ofCrAnListF {φ1 φ2 φ3 : 𝓕.
simp
@[simp]
lemma ι_timeOrderF_superCommuteF_superCommuteF {φ1 φ2 φ3 : 𝓕.CrAnStates} (a b : 𝓕.FieldOpFreeAlgebra) :
lemma ι_timeOrderF_superCommuteF_superCommuteF {φ1 φ2 φ3 : 𝓕.CrAnFieldOp} (a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca * b) = 0 := by
let pb (b : 𝓕.FieldOpFreeAlgebra) (hc : b ∈ Submodule.span ℂ (Set.range ofCrAnListFBasis)) :
Prop := ι 𝓣ᶠ(a * [ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca * b) = 0
@ -181,7 +181,7 @@ lemma ι_timeOrderF_superCommuteF_superCommuteF {φ1 φ2 φ3 : 𝓕.CrAnStates}
· intro x hx hpx
simp_all [pb, hpx]
lemma ι_timeOrderF_superCommuteF_eq_time {φ ψ : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_eq_time {φ ψ : 𝓕.CrAnFieldOp}
(hφψ : crAnTimeOrderRel φ ψ) (hψφ : crAnTimeOrderRel ψ φ) (a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca * b) =
ι ([ofCrAnOpF φ, ofCrAnOpF ψ]ₛca * 𝓣ᶠ(a * b)) := by
@ -277,7 +277,7 @@ lemma ι_timeOrderF_superCommuteF_eq_time {φ ψ : 𝓕.CrAnStates}
· intro x hx hpx
simp_all [pb, hpx]
lemma ι_timeOrderF_superCommuteF_neq_time {φ ψ : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_neq_time {φ ψ : 𝓕.CrAnFieldOp}
(hφψ : ¬ (crAnTimeOrderRel φ ψ ∧ crAnTimeOrderRel ψ φ)) (a b : 𝓕.FieldOpFreeAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca * b) = 0 := by
rw [timeOrderF_timeOrderF_mid]
@ -393,18 +393,18 @@ scoped[FieldSpecification.FieldOpAlgebra] notation "𝓣(" a ")" => timeOrder a
lemma timeOrder_eq_ι_timeOrderF (a : 𝓕.FieldOpFreeAlgebra) :
𝓣(ι a) = ι 𝓣ᶠ(a) := rfl
lemma timeOrder_ofFieldOp_ofFieldOp_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
lemma timeOrder_ofFieldOp_ofFieldOp_ordered {φ ψ : 𝓕.FieldOp} (h : timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = ofFieldOp φ * ofFieldOp ψ := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
timeOrderF_ofFieldOpF_ofFieldOpF_ordered h]
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered {φ ψ : 𝓕.FieldOp} (h : ¬ timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • ofFieldOp ψ * ofFieldOp φ := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered h]
simp
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered_eq_timeOrder {φ ψ : 𝓕.States}
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered_eq_timeOrder {φ ψ : 𝓕.FieldOp}
(h : ¬ timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • 𝓣(ofFieldOp ψ * ofFieldOp φ) := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
@ -417,11 +417,11 @@ lemma timeOrder_ofFieldOpList_nil : 𝓣(ofFieldOpList (𝓕 := 𝓕) []) = 1 :=
simp
@[simp]
lemma timeOrder_ofFieldOpList_singleton (φ : 𝓕.States) :
lemma timeOrder_ofFieldOpList_singleton (φ : 𝓕.FieldOp) :
𝓣(ofFieldOpList [φ]) = ofFieldOpList [φ] := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofFieldOpListF_singleton]
lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
𝓣(ofFieldOpList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
(Finset.filter (fun x =>
(maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs) Finset.univ)⟩) •
@ -429,7 +429,7 @@ lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.S
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_eq_maxTimeField_mul_finset]
rfl
lemma timeOrder_superCommute_eq_time_mid {φ ψ : 𝓕.CrAnStates}
lemma timeOrder_superCommute_eq_time_mid {φ ψ : 𝓕.CrAnFieldOp}
(hφψ : crAnTimeOrderRel φ ψ) (hψφ : crAnTimeOrderRel ψ φ) (a b : 𝓕.FieldOpAlgebra) :
𝓣(a * [ofCrAnFieldOp φ, ofCrAnFieldOp ψ]ₛ * b) =
[ofCrAnFieldOp φ, ofCrAnFieldOp ψ]ₛ * 𝓣(a * b) := by
@ -443,7 +443,7 @@ lemma timeOrder_superCommute_eq_time_mid {φ ψ : 𝓕.CrAnStates}
· simp_all
· simp_all
lemma timeOrder_superCommute_eq_time_left {φ ψ : 𝓕.CrAnStates}
lemma timeOrder_superCommute_eq_time_left {φ ψ : 𝓕.CrAnFieldOp}
(hφψ : crAnTimeOrderRel φ ψ) (hψφ : crAnTimeOrderRel ψ φ) (b : 𝓕.FieldOpAlgebra) :
𝓣([ofCrAnFieldOp φ, ofCrAnFieldOp ψ]ₛ * b) =
[ofCrAnFieldOp φ, ofCrAnFieldOp ψ]ₛ * 𝓣(b) := by
@ -452,7 +452,7 @@ lemma timeOrder_superCommute_eq_time_left {φ ψ : 𝓕.CrAnStates}
rw [timeOrder_superCommute_eq_time_mid hφψ hψφ]
simp
lemma timeOrder_superCommute_neq_time {φ ψ : 𝓕.CrAnStates}
lemma timeOrder_superCommute_neq_time {φ ψ : 𝓕.CrAnFieldOp}
(hφψ : ¬ (crAnTimeOrderRel φ ψ ∧ crAnTimeOrderRel ψ φ)) :
𝓣([ofCrAnFieldOp φ, ofCrAnFieldOp ψ]ₛ) = 0 := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
@ -463,7 +463,7 @@ lemma timeOrder_superCommute_neq_time {φ ψ : 𝓕.CrAnStates}
rw [ι_timeOrderF_superCommuteF_neq_time]
exact hφψ
lemma timeOrder_superCommute_anPart_ofFieldOp_neq_time {φ ψ : 𝓕.States}
lemma timeOrder_superCommute_anPart_ofFieldOp_neq_time {φ ψ : 𝓕.FieldOp}
(hφψ : ¬ (timeOrderRel φ ψ ∧ timeOrderRel ψ φ)) :
𝓣([anPart φ,ofFieldOp ψ]ₛ) = 0 := by
rw [ofFieldOp_eq_sum]

18
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/WicksTheoremNormal.lean
View file

@ -20,7 +20,7 @@ namespace FieldOpAlgebra
open WickContraction
open EqTimeOnly
lemma timeOrder_ofFieldOpList_eqTimeOnly (φs : List 𝓕.States) :
lemma timeOrder_ofFieldOpList_eqTimeOnly (φs : List 𝓕.FieldOp) :
timeOrder (ofFieldOpList φs) = ∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs)}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓣(𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) := by
rw [static_wick_theorem φs]
@ -43,7 +43,7 @@ lemma timeOrder_ofFieldOpList_eqTimeOnly (φs : List 𝓕.States) :
exact x.2
exact x.2
lemma timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.States) :
lemma timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.FieldOp) :
timeOrder (ofFieldOpList φs) = 𝓣(𝓝(ofFieldOpList φs)) +
∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓣(𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) := by
@ -70,14 +70,14 @@ lemma timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.States) :
rw [← e2.symm.sum_comp]
rfl
lemma normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.States) :
lemma normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.FieldOp) :
𝓣(𝓝(ofFieldOpList φs)) = 𝓣(ofFieldOpList φs) -
∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓣(𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) := by
rw [timeOrder_ofFieldOpList_eq_eqTimeOnly_empty]
simp
lemma normalOrder_timeOrder_ofFieldOpList_eq_haveEqTime_sum_not_haveEqTime (φs : List 𝓕.States) :
lemma normalOrder_timeOrder_ofFieldOpList_eq_haveEqTime_sum_not_haveEqTime (φs : List 𝓕.FieldOp) :
𝓣(𝓝(ofFieldOpList φs)) = (∑ (φsΛ : {φsΛ : WickContraction φs.length // ¬ HaveEqTime φsΛ}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ))
+ (∑ (φsΛ : {φsΛ : WickContraction φs.length // HaveEqTime φsΛ}),
@ -93,7 +93,7 @@ lemma normalOrder_timeOrder_ofFieldOpList_eq_haveEqTime_sum_not_haveEqTime (φs
Equiv.sumCompl_apply_inl, Equiv.sumCompl_apply_inr, ne_eq, sub_left_inj, e1]
rw [add_comm]
lemma haveEqTime_wick_sum_eq_split (φs : List 𝓕.States) :
lemma haveEqTime_wick_sum_eq_split (φs : List 𝓕.FieldOp) :
(∑ (φsΛ : {φsΛ : WickContraction φs.length // HaveEqTime φsΛ}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) =
∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}),
@ -122,7 +122,7 @@ lemma haveEqTime_wick_sum_eq_split (φs : List 𝓕.States) :
congr 1
rw [@join_uncontractedListGet]
lemma normalOrder_timeOrder_ofFieldOpList_eq_not_haveEqTime_sub_inductive (φs : List 𝓕.States) :
lemma normalOrder_timeOrder_ofFieldOpList_eq_not_haveEqTime_sub_inductive (φs : List 𝓕.FieldOp) :
𝓣(𝓝(ofFieldOpList φs)) = (∑ (φsΛ : {φsΛ : WickContraction φs.length // ¬ HaveEqTime φsΛ}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ))
+ ∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}),
@ -142,9 +142,9 @@ lemma normalOrder_timeOrder_ofFieldOpList_eq_not_haveEqTime_sub_inductive (φs :
rw [← smul_sub, ← mul_sub]
lemma wicks_theorem_normal_order_empty : 𝓣(𝓝(ofFieldOpList [])) =
∑ (φsΛ : {φsΛ : WickContraction ([] : List 𝓕.States).length // ¬ HaveEqTime φsΛ}),
∑ (φsΛ : {φsΛ : WickContraction ([] : List 𝓕.FieldOp).length // ¬ HaveEqTime φsΛ}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ) := by
let e2 : {φsΛ : WickContraction ([] : List 𝓕.States).length // ¬ HaveEqTime φsΛ} ≃ Unit :=
let e2 : {φsΛ : WickContraction ([] : List 𝓕.FieldOp).length // ¬ HaveEqTime φsΛ} ≃ Unit :=
{
toFun := fun x => (),
invFun := fun x => ⟨empty, by simp⟩,
@ -181,7 +181,7 @@ Wicks theorem for normal ordering followed by time-ordering, states that
for those Wick contraction `φsΛ` which do not have any equal time contractions.
This is compared to the ordinary Wicks theorem which sums over all Wick contractions.
-/
theorem wicks_theorem_normal_order : (φs : List 𝓕.States) →
theorem wicks_theorem_normal_order : (φs : List 𝓕.FieldOp) →
𝓣(𝓝(ofFieldOpList φs)) = ∑ (φsΛ : {φsΛ : WickContraction φs.length // ¬ HaveEqTime φsΛ}),
φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)
| [] => wicks_theorem_normal_order_empty

90
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/Basic.lean
View file

@ -3,7 +3,7 @@ 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.FieldSpecification.CrAnStates
import HepLean.PerturbationTheory.FieldSpecification.CrAnFieldOp
import HepLean.PerturbationTheory.FieldSpecification.CrAnSection
/-!
@ -35,63 +35,63 @@ namespace FieldSpecification
variable {𝓕 : FieldSpecification}
/-- The creation and annihlation free-algebra.
The free algebra generated by `CrAnStates`,
The free algebra generated by `CrAnFieldOp`,
that is a position based states or assymptotic states with a specification of
whether the state is a creation or annihlation state.
As a module `FieldOpFreeAlgebra` is spanned by lists of `CrAnStates`. -/
abbrev FieldOpFreeAlgebra (𝓕 : FieldSpecification) : Type := FreeAlgebra ℂ 𝓕.CrAnStates
As a module `FieldOpFreeAlgebra` is spanned by lists of `CrAnFieldOp`. -/
abbrev FieldOpFreeAlgebra (𝓕 : FieldSpecification) : Type := FreeAlgebra ℂ 𝓕.CrAnFieldOp
namespace FieldOpFreeAlgebra
/-- Maps a creation and annihlation state to the creation and annihlation free-algebra. -/
def ofCrAnOpF (φ : 𝓕.CrAnStates) : FieldOpFreeAlgebra 𝓕 :=
def ofCrAnOpF (φ : 𝓕.CrAnFieldOp) : FieldOpFreeAlgebra 𝓕 :=
FreeAlgebra.ι ℂ φ
/-- Maps a list creation and annihlation state to the creation and annihlation free-algebra
by taking their product. -/
def ofCrAnListF (φs : List 𝓕.CrAnStates) : FieldOpFreeAlgebra 𝓕 := (List.map ofCrAnOpF φs).prod
def ofCrAnListF (φs : List 𝓕.CrAnFieldOp) : FieldOpFreeAlgebra 𝓕 := (List.map ofCrAnOpF φs).prod
@[simp]
lemma ofCrAnListF_nil : ofCrAnListF ([] : List 𝓕.CrAnStates) = 1 := rfl
lemma ofCrAnListF_nil : ofCrAnListF ([] : List 𝓕.CrAnFieldOp) = 1 := rfl
lemma ofCrAnListF_cons (φ : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates) :
lemma ofCrAnListF_cons (φ : 𝓕.CrAnFieldOp) (φs : List 𝓕.CrAnFieldOp) :
ofCrAnListF (φ :: φs) = ofCrAnOpF φ * ofCrAnListF φs := rfl
lemma ofCrAnListF_append (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnListF_append (φs φs' : List 𝓕.CrAnFieldOp) :
ofCrAnListF (φs ++ φs') = ofCrAnListF φs * ofCrAnListF φs' := by
simp [ofCrAnListF, List.map_append]
lemma ofCrAnListF_singleton (φ : 𝓕.CrAnStates) :
lemma ofCrAnListF_singleton (φ : 𝓕.CrAnFieldOp) :
ofCrAnListF [φ] = ofCrAnOpF φ := by simp [ofCrAnListF]
/-- Maps a state to the sum of creation and annihilation operators in
creation and annihilation free-algebra. -/
def ofFieldOpF (φ : 𝓕.States) : FieldOpFreeAlgebra 𝓕 :=
∑ (i : 𝓕.statesToCrAnType φ), ofCrAnOpF ⟨φ, i⟩
def ofFieldOpF (φ : 𝓕.FieldOp) : FieldOpFreeAlgebra 𝓕 :=
∑ (i : 𝓕.fieldOpToCrAnType φ), ofCrAnOpF ⟨φ, i⟩
/-- Maps a list of states to the creation and annihilation free-algebra by taking
the product of their sums of creation and annihlation operators.
Roughly `[φ1, φ2]` gets sent to `(φ1ᶜ+ φ1ᵃ) * (φ2ᶜ+ φ2ᵃ)` etc. -/
def ofFieldOpListF (φs : List 𝓕.States) : FieldOpFreeAlgebra 𝓕 := (List.map ofFieldOpF φs).prod
def ofFieldOpListF (φs : List 𝓕.FieldOp) : FieldOpFreeAlgebra 𝓕 := (List.map ofFieldOpF φs).prod
/-- Coercion from `List 𝓕.States` to `FieldOpFreeAlgebra 𝓕` through `ofFieldOpListF`. -/
instance : Coe (List 𝓕.States) (FieldOpFreeAlgebra 𝓕) := ⟨ofFieldOpListF⟩
/-- Coercion from `List 𝓕.FieldOp` to `FieldOpFreeAlgebra 𝓕` through `ofFieldOpListF`. -/
instance : Coe (List 𝓕.FieldOp) (FieldOpFreeAlgebra 𝓕) := ⟨ofFieldOpListF⟩
@[simp]
lemma ofFieldOpListF_nil : ofFieldOpListF ([] : List 𝓕.States) = 1 := rfl
lemma ofFieldOpListF_nil : ofFieldOpListF ([] : List 𝓕.FieldOp) = 1 := rfl
lemma ofFieldOpListF_cons (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma ofFieldOpListF_cons (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
ofFieldOpListF (φ :: φs) = ofFieldOpF φ * ofFieldOpListF φs := rfl
lemma ofFieldOpListF_singleton (φ : 𝓕.States) :
lemma ofFieldOpListF_singleton (φ : 𝓕.FieldOp) :
ofFieldOpListF [φ] = ofFieldOpF φ := by simp [ofFieldOpListF]
lemma ofFieldOpListF_append (φs φs' : List 𝓕.States) :
lemma ofFieldOpListF_append (φs φs' : List 𝓕.FieldOp) :
ofFieldOpListF (φs ++ φs') = ofFieldOpListF φs * ofFieldOpListF φs' := by
dsimp only [ofFieldOpListF]
rw [List.map_append, List.prod_append]
lemma ofFieldOpListF_sum (φs : List 𝓕.States) :
lemma ofFieldOpListF_sum (φs : List 𝓕.FieldOp) :
ofFieldOpListF φs = ∑ (s : CrAnSection φs), ofCrAnListF s.1 := by
induction φs with
| nil => simp
@ -113,60 +113,60 @@ lemma ofFieldOpListF_sum (φs : List 𝓕.States) :
/-- The algebra map taking an element of the free-state algbra to
the part of it in the creation and annihlation free algebra
spanned by creation operators. -/
def crPartF : 𝓕.States → 𝓕.FieldOpFreeAlgebra := fun φ =>
def crPartF : 𝓕.FieldOp → 𝓕.FieldOpFreeAlgebra := fun φ =>
match φ with
| States.inAsymp φ => ofCrAnOpF ⟨States.inAsymp φ, ()⟩
| States.position φ => ofCrAnOpF ⟨States.position φ, CreateAnnihilate.create⟩
| States.outAsymp _ => 0
| FieldOp.inAsymp φ => ofCrAnOpF ⟨FieldOp.inAsymp φ, ()⟩
| FieldOp.position φ => ofCrAnOpF ⟨FieldOp.position φ, CreateAnnihilate.create⟩
| FieldOp.outAsymp _ => 0
@[simp]
lemma crPartF_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPartF (States.inAsymp φ) = ofCrAnOpF ⟨States.inAsymp φ, ()⟩ := by
crPartF (FieldOp.inAsymp φ) = ofCrAnOpF ⟨FieldOp.inAsymp φ, ()⟩ := by
simp [crPartF]
@[simp]
lemma crPartF_position (φ : 𝓕.PositionStates) :
crPartF (States.position φ) =
ofCrAnOpF ⟨States.position φ, CreateAnnihilate.create⟩ := by
lemma crPartF_position (φ : 𝓕.PositionFieldOp) :
crPartF (FieldOp.position φ) =
ofCrAnOpF ⟨FieldOp.position φ, CreateAnnihilate.create⟩ := by
simp [crPartF]
@[simp]
lemma crPartF_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPartF (States.outAsymp φ) = 0 := by
crPartF (FieldOp.outAsymp φ) = 0 := by
simp [crPartF]
/-- The algebra map taking an element of the free-state algbra to
the part of it in the creation and annihilation free algebra
spanned by annihilation operators. -/
def anPartF : 𝓕.States → 𝓕.FieldOpFreeAlgebra := fun φ =>
def anPartF : 𝓕.FieldOp → 𝓕.FieldOpFreeAlgebra := fun φ =>
match φ with
| States.inAsymp _ => 0
| States.position φ => ofCrAnOpF ⟨States.position φ, CreateAnnihilate.annihilate⟩
| States.outAsymp φ => ofCrAnOpF ⟨States.outAsymp φ, ()⟩
| FieldOp.inAsymp _ => 0
| FieldOp.position φ => ofCrAnOpF ⟨FieldOp.position φ, CreateAnnihilate.annihilate⟩
| FieldOp.outAsymp φ => ofCrAnOpF ⟨FieldOp.outAsymp φ, ()⟩
@[simp]
lemma anPartF_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPartF (States.inAsymp φ) = 0 := by
anPartF (FieldOp.inAsymp φ) = 0 := by
simp [anPartF]
@[simp]
lemma anPartF_position (φ : 𝓕.PositionStates) :
anPartF (States.position φ) =
ofCrAnOpF ⟨States.position φ, CreateAnnihilate.annihilate⟩ := by
lemma anPartF_position (φ : 𝓕.PositionFieldOp) :
anPartF (FieldOp.position φ) =
ofCrAnOpF ⟨FieldOp.position φ, CreateAnnihilate.annihilate⟩ := by
simp [anPartF]
@[simp]
lemma anPartF_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPartF (States.outAsymp φ) = ofCrAnOpF ⟨States.outAsymp φ, ()⟩ := by
anPartF (FieldOp.outAsymp φ) = ofCrAnOpF ⟨FieldOp.outAsymp φ, ()⟩ := by
simp [anPartF]
lemma ofFieldOpF_eq_crPartF_add_anPartF (φ : 𝓕.States) :
lemma ofFieldOpF_eq_crPartF_add_anPartF (φ : 𝓕.FieldOp) :
ofFieldOpF φ = crPartF φ + anPartF φ := by
rw [ofFieldOpF]
cases φ with
| inAsymp φ => simp [statesToCrAnType]
| position φ => simp [statesToCrAnType, CreateAnnihilate.sum_eq]
| outAsymp φ => simp [statesToCrAnType]
| inAsymp φ => simp [fieldOpToCrAnType]
| position φ => simp [fieldOpToCrAnType, CreateAnnihilate.sum_eq]
| outAsymp φ => simp [fieldOpToCrAnType]
/-!
@ -174,12 +174,12 @@ lemma ofFieldOpF_eq_crPartF_add_anPartF (φ : 𝓕.States) :
-/
/-- The basis of the free creation and annihilation algebra formed by lists of CrAnStates. -/
noncomputable def ofCrAnListFBasis : Basis (List 𝓕.CrAnStates) ℂ (FieldOpFreeAlgebra 𝓕) where
/-- The basis of the free creation and annihilation algebra formed by lists of CrAnFieldOp. -/
noncomputable def ofCrAnListFBasis : Basis (List 𝓕.CrAnFieldOp) ℂ (FieldOpFreeAlgebra 𝓕) where
repr := FreeAlgebra.equivMonoidAlgebraFreeMonoid.toLinearEquiv
@[simp]
lemma ofListBasis_eq_ofList (φs : List 𝓕.CrAnStates) :
lemma ofListBasis_eq_ofList (φs : List 𝓕.CrAnFieldOp) :
ofCrAnListFBasis φs = ofCrAnListF φs := by
simp only [ofCrAnListFBasis, FreeAlgebra.equivMonoidAlgebraFreeMonoid, MonoidAlgebra.of_apply,
Basis.coe_ofRepr, AlgEquiv.toLinearEquiv_symm, AlgEquiv.toLinearEquiv_apply,

12
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/Grading.lean
View file

@ -24,12 +24,12 @@ noncomputable section
def statisticSubmodule (f : FieldStatistic) : Submodule ℂ 𝓕.FieldOpFreeAlgebra :=
Submodule.span ℂ {a | ∃ φs, a = ofCrAnListF φs ∧ (𝓕 |>ₛ φs) = f}
lemma ofCrAnListF_mem_statisticSubmodule_of (φs : List 𝓕.CrAnStates) (f : FieldStatistic)
lemma ofCrAnListF_mem_statisticSubmodule_of (φs : List 𝓕.CrAnFieldOp) (f : FieldStatistic)
(h : (𝓕 |>ₛ φs) = f) :
ofCrAnListF φs ∈ statisticSubmodule f := by
refine Submodule.mem_span.mpr fun _ a => a ⟨φs, ⟨rfl, h⟩⟩
lemma ofCrAnListF_bosonic_or_fermionic (φs : List 𝓕.CrAnStates) :
lemma ofCrAnListF_bosonic_or_fermionic (φs : List 𝓕.CrAnFieldOp) :
ofCrAnListF φs ∈ statisticSubmodule bosonic ∨ ofCrAnListF φs ∈ statisticSubmodule fermionic := by
by_cases h : (𝓕 |>ₛ φs) = bosonic
· left
@ -37,7 +37,7 @@ lemma ofCrAnListF_bosonic_or_fermionic (φs : List 𝓕.CrAnStates) :
· right
exact ofCrAnListF_mem_statisticSubmodule_of φs fermionic (by simpa using h)
lemma ofCrAnOpF_bosonic_or_fermionic (φ : 𝓕.CrAnStates) :
lemma ofCrAnOpF_bosonic_or_fermionic (φ : 𝓕.CrAnFieldOp) :
ofCrAnOpF φ ∈ statisticSubmodule bosonic ∨ ofCrAnOpF φ ∈ statisticSubmodule fermionic := by
rw [← ofCrAnListF_singleton]
exact ofCrAnListF_bosonic_or_fermionic [φ]
@ -50,7 +50,7 @@ def bosonicProj : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] statisticSubmodule (𝓕 :
else
0
lemma bosonicProj_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma bosonicProj_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
bosonicProj (ofCrAnListF φs) = if h : (𝓕 |>ₛ φs) = bosonic then
⟨ofCrAnListF φs, Submodule.mem_span.mpr fun _ a => a ⟨φs, ⟨rfl, h⟩⟩⟩ else 0 := by
conv_lhs =>
@ -110,13 +110,13 @@ def fermionicProj : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] statisticSubmodule (𝓕
else
0
lemma fermionicProj_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma fermionicProj_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
fermionicProj (ofCrAnListF φs) = if h : (𝓕 |>ₛ φs) = fermionic then
⟨ofCrAnListF φs, Submodule.mem_span.mpr fun _ a => a ⟨φs, ⟨rfl, h⟩⟩⟩ else 0 := by
conv_lhs =>
rw [← ofListBasis_eq_ofList, fermionicProj, Basis.constr_basis]
lemma fermionicProj_ofCrAnListF_if_bosonic (φs : List 𝓕.CrAnStates) :
lemma fermionicProj_ofCrAnListF_if_bosonic (φs : List 𝓕.CrAnFieldOp) :
fermionicProj (ofCrAnListF φs) = if h : (𝓕 |>ₛ φs) = bosonic then
0 else ⟨ofCrAnListF φs, Submodule.mem_span.mpr fun _ a => a ⟨φs, ⟨rfl,
by simpa using h⟩⟩⟩ := by

2
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/NormTimeOrder.lean
View file

@ -35,7 +35,7 @@ def normTimeOrder : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕
@[inherit_doc normTimeOrder]
scoped[FieldSpecification.FieldOpFreeAlgebra] notation "𝓣𝓝ᶠ(" a ")" => normTimeOrder a
lemma normTimeOrder_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma normTimeOrder_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
𝓣𝓝ᶠ(ofCrAnListF φs) = normTimeOrderSign φs • ofCrAnListF (normTimeOrderList φs) := by
rw [← ofListBasis_eq_ofList]
simp only [normTimeOrder, Basis.constr_basis]

92
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/NormalOrder.lean
View file

@ -12,7 +12,7 @@ import HepLean.PerturbationTheory.Koszul.KoszulSign
In the module
`HepLean.PerturbationTheory.FieldSpecification.NormalOrder`
we defined the normal ordering of a list of `CrAnStates`.
we defined the normal ordering of a list of `CrAnFieldOp`.
In this module we extend the normal ordering to a linear map on `FieldOpFreeAlgebra`.
We derive properties of this normal ordering.
@ -29,7 +29,7 @@ noncomputable section
/-- The linear map on the free creation and annihlation
algebra defined as the map taking
a list of CrAnStates to the normal-ordered list of states multiplied by
a list of CrAnFieldOp to the normal-ordered list of states multiplied by
the sign corresponding to the number of fermionic-fermionic
exchanges done in ordering. -/
def normalOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕 :=
@ -39,11 +39,11 @@ def normalOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕 :
@[inherit_doc normalOrderF]
scoped[FieldSpecification.FieldOpFreeAlgebra] notation "𝓝ᶠ(" a ")" => normalOrderF a
lemma normalOrderF_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma normalOrderF_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
𝓝ᶠ(ofCrAnListF φs) = normalOrderSign φs • ofCrAnListF (normalOrderList φs) := by
rw [← ofListBasis_eq_ofList, normalOrderF, Basis.constr_basis]
lemma ofCrAnListF_eq_normalOrderF (φs : List 𝓕.CrAnStates) :
lemma ofCrAnListF_eq_normalOrderF (φs : List 𝓕.CrAnFieldOp) :
ofCrAnListF (normalOrderList φs) = normalOrderSign φs • 𝓝ᶠ(ofCrAnListF φs) := by
rw [normalOrderF_ofCrAnListF, normalOrderList, smul_smul, normalOrderSign,
Wick.koszulSign_mul_self, one_smul]
@ -119,14 +119,14 @@ lemma normalOrderF_normalOrderF_left (a b : 𝓕.FieldOpFreeAlgebra) : 𝓝ᶠ(a
-/
lemma normalOrderF_ofCrAnListF_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
lemma normalOrderF_ofCrAnListF_cons_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnFieldOp) :
𝓝ᶠ(ofCrAnListF (φ :: φs)) = ofCrAnOpF φ * 𝓝ᶠ(ofCrAnListF φs) := by
rw [normalOrderF_ofCrAnListF, normalOrderSign_cons_create φ hφ,
normalOrderList_cons_create φ hφ φs]
rw [ofCrAnListF_cons, normalOrderF_ofCrAnListF, mul_smul_comm]
lemma normalOrderF_create_mul (φ : 𝓕.CrAnStates)
lemma normalOrderF_create_mul (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (a : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(ofCrAnOpF φ * a) = ofCrAnOpF φ * 𝓝ᶠ(a) := by
change (normalOrderF ∘ₗ mulLinearMap (ofCrAnOpF φ)) a =
@ -136,14 +136,14 @@ lemma normalOrderF_create_mul (φ : 𝓕.CrAnStates)
LinearMap.coe_comp, Function.comp_apply]
rw [← ofCrAnListF_cons, normalOrderF_ofCrAnListF_cons_create φ hφ]
lemma normalOrderF_ofCrAnListF_append_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
lemma normalOrderF_ofCrAnListF_append_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnFieldOp) :
𝓝ᶠ(ofCrAnListF (φs ++ [φ])) = 𝓝ᶠ(ofCrAnListF φs) * ofCrAnOpF φ := by
rw [normalOrderF_ofCrAnListF, normalOrderSign_append_annihlate φ hφ φs,
normalOrderList_append_annihilate φ hφ φs, ofCrAnListF_append, ofCrAnListF_singleton,
normalOrderF_ofCrAnListF, smul_mul_assoc]
lemma normalOrderF_mul_annihilate (φ : 𝓕.CrAnStates)
lemma normalOrderF_mul_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate)
(a : FieldOpFreeAlgebra 𝓕) : 𝓝ᶠ(a * ofCrAnOpF φ) = 𝓝ᶠ(a) * ofCrAnOpF φ := by
change (normalOrderF ∘ₗ mulLinearMap.flip (ofCrAnOpF φ)) a =
@ -154,19 +154,19 @@ lemma normalOrderF_mul_annihilate (φ : 𝓕.CrAnStates)
rw [← ofCrAnListF_singleton, ← ofCrAnListF_append, ofCrAnListF_singleton,
normalOrderF_ofCrAnListF_append_annihilate φ hφ]
lemma normalOrderF_crPartF_mul (φ : 𝓕.States) (a : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_crPartF_mul (φ : 𝓕.FieldOp) (a : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(crPartF φ * a) =
crPartF φ * 𝓝ᶠ(a) := by
match φ with
| .inAsymp φ =>
rw [crPartF]
exact normalOrderF_create_mul ⟨States.inAsymp φ, ()⟩ rfl a
exact normalOrderF_create_mul ⟨FieldOp.inAsymp φ, ()⟩ rfl a
| .position φ =>
rw [crPartF]
exact normalOrderF_create_mul _ rfl _
| .outAsymp φ => simp
lemma normalOrderF_mul_anPartF (φ : 𝓕.States) (a : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_mul_anPartF (φ : 𝓕.FieldOp) (a : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(a * anPartF φ) =
𝓝ᶠ(a) * anPartF φ := by
match φ with
@ -185,9 +185,9 @@ lemma normalOrderF_mul_anPartF (φ : 𝓕.States) (a : FieldOpFreeAlgebra 𝓕)
The main result of this section is `normalOrderF_superCommuteF_annihilate_create`.
-/
lemma normalOrderF_swap_create_annihlate_ofCrAnListF_ofCrAnListF (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate_ofCrAnListF_ofCrAnListF (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs φs' : List 𝓕.CrAnStates) :
(φs φs' : List 𝓕.CrAnFieldOp) :
𝓝ᶠ(ofCrAnListF φs' * ofCrAnOpF φc * ofCrAnOpF φa * ofCrAnListF φs) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
𝓝ᶠ(ofCrAnListF φs' * ofCrAnOpF φa * ofCrAnOpF φc * ofCrAnListF φs) := by
rw [mul_assoc, mul_assoc, ← ofCrAnListF_cons, ← ofCrAnListF_cons, ← ofCrAnListF_append]
@ -196,9 +196,9 @@ lemma normalOrderF_swap_create_annihlate_ofCrAnListF_ofCrAnListF (φc φa : 𝓕
rw [ofCrAnListF_append, ofCrAnListF_cons, ofCrAnListF_cons]
noncomm_ring
lemma normalOrderF_swap_create_annihlate_ofCrAnListF (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate_ofCrAnListF (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) (a : 𝓕.FieldOpFreeAlgebra) :
(φs : List 𝓕.CrAnFieldOp) (a : 𝓕.FieldOpFreeAlgebra) :
𝓝ᶠ(ofCrAnListF φs * ofCrAnOpF φc * ofCrAnOpF φa * a) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
𝓝ᶠ(ofCrAnListF φs * ofCrAnOpF φa * ofCrAnOpF φc * a) := by
change (normalOrderF ∘ₗ mulLinearMap (ofCrAnListF φs * ofCrAnOpF φc * ofCrAnOpF φa)) a =
@ -210,7 +210,7 @@ lemma normalOrderF_swap_create_annihlate_ofCrAnListF (φc φa : 𝓕.CrAnStates)
rw [normalOrderF_swap_create_annihlate_ofCrAnListF_ofCrAnListF φc φa hφc hφa]
rfl
lemma normalOrderF_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.FieldOpFreeAlgebra) :
𝓝ᶠ(a * ofCrAnOpF φc * ofCrAnOpF φa * b) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
@ -225,7 +225,7 @@ lemma normalOrderF_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
normalOrderF_swap_create_annihlate_ofCrAnListF φc φa hφc hφa]
rfl
lemma normalOrderF_superCommuteF_create_annihilate (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_superCommuteF_create_annihilate (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.FieldOpFreeAlgebra) :
𝓝ᶠ(a * [ofCrAnOpF φc, ofCrAnOpF φa]ₛca * b) = 0 := by
@ -234,7 +234,7 @@ lemma normalOrderF_superCommuteF_create_annihilate (φc φa : 𝓕.CrAnStates)
normalOrderF_swap_create_annihlate φc φa hφc hφa]
simp
lemma normalOrderF_superCommuteF_annihilate_create (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_superCommuteF_annihilate_create (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.FieldOpFreeAlgebra) :
𝓝ᶠ(a * [ofCrAnOpF φa, ofCrAnOpF φc]ₛca * b) = 0 := by
@ -243,7 +243,7 @@ lemma normalOrderF_superCommuteF_annihilate_create (φc φa : 𝓕.CrAnStates)
Algebra.smul_mul_assoc, map_neg, map_smul, neg_eq_zero, smul_eq_zero]
exact Or.inr (normalOrderF_superCommuteF_create_annihilate φc φa hφc hφa ..)
lemma normalOrderF_swap_crPartF_anPartF (φ φ' : 𝓕.States) (a b : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_swap_crPartF_anPartF (φ φ' : 𝓕.FieldOp) (a b : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(a * (crPartF φ) * (anPartF φ') * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓝ᶠ(a * (anPartF φ') * (crPartF φ) * b) := by
@ -253,22 +253,22 @@ lemma normalOrderF_swap_crPartF_anPartF (φ φ' : 𝓕.States) (a b : FieldOpFre
| .position φ, .position φ' =>
simp only [crPartF_position, anPartF_position, instCommGroup.eq_1]
rw [normalOrderF_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod]
rfl; rfl
| .inAsymp φ, .outAsymp φ' =>
simp only [crPartF_negAsymp, anPartF_posAsymp, instCommGroup.eq_1]
rw [normalOrderF_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod]
rfl; rfl
| .inAsymp φ, .position φ' =>
simp only [crPartF_negAsymp, anPartF_position, instCommGroup.eq_1]
rw [normalOrderF_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod]
rfl; rfl
| .position φ, .outAsymp φ' =>
simp only [crPartF_position, anPartF_posAsymp, instCommGroup.eq_1]
rw [normalOrderF_swap_create_annihlate]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnStatesToStates_prod]
simp only [instCommGroup.eq_1, crAnStatistics, Function.comp_apply, crAnFieldOpToFieldOp_prod]
rfl; rfl
/-!
@ -279,13 +279,13 @@ Using the results from above.
-/
lemma normalOrderF_swap_anPartF_crPartF (φ φ' : 𝓕.States) (a b : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_swap_anPartF_crPartF (φ φ' : 𝓕.FieldOp) (a b : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(a * (anPartF φ) * (crPartF φ') * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝ᶠ(a * (crPartF φ') *
(anPartF φ) * b) := by
simp [normalOrderF_swap_crPartF_anPartF, smul_smul]
lemma normalOrderF_superCommuteF_crPartF_anPartF (φ φ' : 𝓕.States) (a b : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_superCommuteF_crPartF_anPartF (φ φ' : 𝓕.FieldOp) (a b : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(a * superCommuteF
(crPartF φ) (anPartF φ') * b) = 0 := by
match φ, φ' with
@ -304,7 +304,7 @@ lemma normalOrderF_superCommuteF_crPartF_anPartF (φ φ' : 𝓕.States) (a b : F
rw [crPartF_position, anPartF_posAsymp]
exact normalOrderF_superCommuteF_create_annihilate _ _ rfl rfl ..
lemma normalOrderF_superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) (a b : FieldOpFreeAlgebra 𝓕) :
lemma normalOrderF_superCommuteF_anPartF_crPartF (φ φ' : 𝓕.FieldOp) (a b : FieldOpFreeAlgebra 𝓕) :
𝓝ᶠ(a * superCommuteF
(anPartF φ) (crPartF φ') * b) = 0 := by
match φ, φ' with
@ -330,7 +330,7 @@ lemma normalOrderF_superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) (a b : F
-/
@[simp]
lemma normalOrderF_crPartF_mul_crPartF (φ φ' : 𝓕.States) :
lemma normalOrderF_crPartF_mul_crPartF (φ φ' : 𝓕.FieldOp) :
𝓝ᶠ(crPartF φ * crPartF φ') =
crPartF φ * crPartF φ' := by
rw [normalOrderF_crPartF_mul]
@ -339,7 +339,7 @@ lemma normalOrderF_crPartF_mul_crPartF (φ φ' : 𝓕.States) :
simp
@[simp]
lemma normalOrderF_anPartF_mul_anPartF (φ φ' : 𝓕.States) :
lemma normalOrderF_anPartF_mul_anPartF (φ φ' : 𝓕.FieldOp) :
𝓝ᶠ(anPartF φ * anPartF φ') =
anPartF φ * anPartF φ' := by
rw [normalOrderF_mul_anPartF]
@ -348,7 +348,7 @@ lemma normalOrderF_anPartF_mul_anPartF (φ φ' : 𝓕.States) :
simp
@[simp]
lemma normalOrderF_crPartF_mul_anPartF (φ φ' : 𝓕.States) :
lemma normalOrderF_crPartF_mul_anPartF (φ φ' : 𝓕.FieldOp) :
𝓝ᶠ(crPartF φ * anPartF φ') =
crPartF φ * anPartF φ' := by
rw [normalOrderF_crPartF_mul]
@ -357,7 +357,7 @@ lemma normalOrderF_crPartF_mul_anPartF (φ φ' : 𝓕.States) :
simp
@[simp]
lemma normalOrderF_anPartF_mul_crPartF (φ φ' : 𝓕.States) :
lemma normalOrderF_anPartF_mul_crPartF (φ φ' : 𝓕.FieldOp) :
𝓝ᶠ(anPartF φ * crPartF φ') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
(crPartF φ' * anPartF φ) := by
@ -367,7 +367,7 @@ lemma normalOrderF_anPartF_mul_crPartF (φ φ' : 𝓕.States) :
rw [← mul_assoc, normalOrderF_swap_anPartF_crPartF]
simp
lemma normalOrderF_ofFieldOpF_mul_ofFieldOpF (φ φ' : 𝓕.States) :
lemma normalOrderF_ofFieldOpF_mul_ofFieldOpF (φ φ' : 𝓕.FieldOp) :
𝓝ᶠ(ofFieldOpF φ * ofFieldOpF φ') =
crPartF φ * crPartF φ' +
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
@ -388,8 +388,8 @@ lemma normalOrderF_ofFieldOpF_mul_ofFieldOpF (φ φ' : 𝓕.States) :
TODO "Split the following two lemmas up into smaller parts."
lemma normalOrderF_superCommuteF_ofCrAnListF_create_create_ofCrAnListF
(φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create) (φs φs' : List 𝓕.CrAnStates) :
(φc φc' : 𝓕.CrAnFieldOp) (hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create) (φs φs' : List 𝓕.CrAnFieldOp) :
(𝓝ᶠ(ofCrAnListF φs * [ofCrAnOpF φc, ofCrAnOpF φc']ₛca * ofCrAnListF φs')) =
normalOrderSign (φs ++ φc' :: φc :: φs') •
(ofCrAnListF (createFilter φs) * [ofCrAnOpF φc, ofCrAnOpF φc']ₛca *
@ -447,10 +447,10 @@ lemma normalOrderF_superCommuteF_ofCrAnListF_create_create_ofCrAnListF
rw [ofCrAnListF_append, ofCrAnListF_singleton, ofCrAnListF_singleton, smul_mul_assoc]
lemma normalOrderF_superCommuteF_ofCrAnListF_annihilate_annihilate_ofCrAnListF
(φa φa' : 𝓕.CrAnStates)
(φa φa' : 𝓕.CrAnFieldOp)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate)
(φs φs' : List 𝓕.CrAnStates) :
(φs φs' : List 𝓕.CrAnFieldOp) :
𝓝ᶠ(ofCrAnListF φs * [ofCrAnOpF φa, ofCrAnOpF φa']ₛca * ofCrAnListF φs') =
normalOrderSign (φs ++ φa' :: φa :: φs') •
(ofCrAnListF (createFilter (φs ++ φs'))
@ -520,15 +520,15 @@ lemma normalOrderF_superCommuteF_ofCrAnListF_annihilate_annihilate_ofCrAnListF
-/
lemma ofCrAnListF_superCommuteF_normalOrderF_ofCrAnListF (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnListF_superCommuteF_normalOrderF_ofCrAnListF (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs, 𝓝ᶠ(ofCrAnListF φs')]ₛca =
ofCrAnListF φs * 𝓝ᶠ(ofCrAnListF φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofCrAnListF φs') * ofCrAnListF φs := by
simp [normalOrderF_ofCrAnListF, map_smul, superCommuteF_ofCrAnListF_ofCrAnListF, ofCrAnListF_append,
smul_sub, smul_smul, mul_comm]
lemma ofCrAnListF_superCommuteF_normalOrderF_ofFieldOpListF (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnListF φs, 𝓝ᶠ(ofFieldOpListF φs')]ₛca =
lemma ofCrAnListF_superCommuteF_normalOrderF_ofFieldOpListF (φs : List 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) : [ofCrAnListF φs, 𝓝ᶠ(ofFieldOpListF φs')]ₛca =
ofCrAnListF φs * 𝓝ᶠ(ofFieldOpListF φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnListF φs := by
rw [ofFieldOpListF_sum, map_sum, Finset.mul_sum, Finset.smul_sum, Finset.sum_mul,
@ -544,21 +544,21 @@ lemma ofCrAnListF_superCommuteF_normalOrderF_ofFieldOpListF (φs : List 𝓕.CrA
-/
lemma ofCrAnListF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) :
lemma ofCrAnListF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) :
ofCrAnListF φs * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnListF φs
+ [ofCrAnListF φs, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by
simp [ofCrAnListF_superCommuteF_normalOrderF_ofFieldOpListF]
lemma ofCrAnOpF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.States) : ofCrAnOpF φ * 𝓝ᶠ(ofFieldOpListF φs') =
lemma ofCrAnOpF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) : ofCrAnOpF φ * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs') * ofCrAnOpF φ
+ [ofCrAnOpF φ, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by
simp [← ofCrAnListF_singleton, ofCrAnListF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF]
lemma anPartF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.States)
(φs' : List 𝓕.States) :
lemma anPartF_mul_normalOrderF_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.FieldOp)
(φs' : List 𝓕.FieldOp) :
anPartF φ * 𝓝ᶠ(ofFieldOpListF φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofFieldOpListF φs' * anPartF φ)
+ [anPartF φ, 𝓝ᶠ(ofFieldOpListF φs')]ₛca := by

140
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/SuperCommute.lean
View file

@ -42,13 +42,13 @@ scoped[FieldSpecification.FieldOpFreeAlgebra] notation "[" φs "," φs' "]ₛca"
-/
lemma superCommuteF_ofCrAnListF_ofCrAnListF (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnListF_ofCrAnListF (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs, ofCrAnListF φs']ₛca =
ofCrAnListF (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnListF (φs' ++ φs) := by
rw [← ofListBasis_eq_ofList, ← ofListBasis_eq_ofList]
simp only [superCommuteF, Basis.constr_basis]
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnOpF φ, ofCrAnOpF φ']ₛca =
ofCrAnOpF φ * ofCrAnOpF φ' - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofCrAnOpF φ' * ofCrAnOpF φ := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
@ -57,7 +57,7 @@ lemma superCommuteF_ofCrAnOpF_ofCrAnOpF (φ φ' : 𝓕.CrAnStates) :
rw [ofCrAnListF_append]
rw [FieldStatistic.ofList_singleton, FieldStatistic.ofList_singleton, smul_mul_assoc]
lemma superCommuteF_ofCrAnListF_ofFieldOpFsList (φcas : List 𝓕.CrAnStates) (φs : List 𝓕.States) :
lemma superCommuteF_ofCrAnListF_ofFieldOpFsList (φcas : List 𝓕.CrAnFieldOp) (φs : List 𝓕.FieldOp) :
[ofCrAnListF φcas, ofFieldOpListF φs]ₛca = ofCrAnListF φcas * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofCrAnListF φcas := by
conv_lhs => rw [ofFieldOpListF_sum]
@ -70,7 +70,7 @@ lemma superCommuteF_ofCrAnListF_ofFieldOpFsList (φcas : List 𝓕.CrAnStates) (
← Finset.sum_mul, ← ofFieldOpListF_sum]
simp
lemma superCommuteF_ofFieldOpListF_ofFieldOpFsList (φ : List 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_ofFieldOpListF_ofFieldOpFsList (φ : List 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[ofFieldOpListF φ, ofFieldOpListF φs]ₛca = ofFieldOpListF φ * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofFieldOpListF φ := by
conv_lhs => rw [ofFieldOpListF_sum]
@ -83,165 +83,165 @@ lemma superCommuteF_ofFieldOpListF_ofFieldOpFsList (φ : List 𝓕.States) (φs
Algebra.smul_mul_assoc, Finset.sum_sub_distrib]
rw [← Finset.sum_mul, ← Finset.smul_sum, ← Finset.mul_sum, ← ofFieldOpListF_sum]
lemma superCommuteF_ofFieldOpF_ofFieldOpFsList (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_ofFieldOpF_ofFieldOpFsList (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[ofFieldOpF φ, ofFieldOpListF φs]ₛca = ofFieldOpF φ * ofFieldOpListF φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs * ofFieldOpF φ := by
rw [← ofFieldOpListF_singleton, superCommuteF_ofFieldOpListF_ofFieldOpFsList, ofFieldOpListF_singleton]
simp
lemma superCommuteF_ofFieldOpListF_ofFieldOpF (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma superCommuteF_ofFieldOpListF_ofFieldOpF (φs : List 𝓕.FieldOp) (φ : 𝓕.FieldOp) :
[ofFieldOpListF φs, ofFieldOpF φ]ₛca = ofFieldOpListF φs * ofFieldOpF φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOpF φ * ofFieldOpListF φs := by
rw [← ofFieldOpListF_singleton, superCommuteF_ofFieldOpListF_ofFieldOpFsList, ofFieldOpListF_singleton]
simp
lemma superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) :
lemma superCommuteF_anPartF_crPartF (φ φ' : 𝓕.FieldOp) :
[anPartF φ, crPartF φ']ₛca = anPartF φ * crPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * anPartF φ := by
match φ, φ' with
| States.inAsymp φ, _ =>
| FieldOp.inAsymp φ, _ =>
simp
| _, States.outAsymp φ =>
| _, FieldOp.outAsymp φ =>
simp only [crPartF_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [anPartF_position, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.outAsymp φ, States.position φ' =>
| FieldOp.outAsymp φ, FieldOp.position φ' =>
simp only [anPartF_posAsymp, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.position φ, States.inAsymp φ' =>
| FieldOp.position φ, FieldOp.inAsymp φ' =>
simp only [anPartF_position, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp only [List.singleton_append, instCommGroup.eq_1, crAnStatistics,
FieldStatistic.ofList_singleton, Function.comp_apply, crAnStatesToStates_prod, ←
FieldStatistic.ofList_singleton, Function.comp_apply, crAnFieldOpToFieldOp_prod, ←
ofCrAnListF_append]
| States.outAsymp φ, States.inAsymp φ' =>
| FieldOp.outAsymp φ, FieldOp.inAsymp φ' =>
simp only [anPartF_posAsymp, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
lemma superCommuteF_crPartF_anPartF (φ φ' : 𝓕.States) :
lemma superCommuteF_crPartF_anPartF (φ φ' : 𝓕.FieldOp) :
[crPartF φ, anPartF φ']ₛca = crPartF φ * anPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * crPartF φ := by
match φ, φ' with
| States.outAsymp φ, _ =>
| FieldOp.outAsymp φ, _ =>
simp only [crPartF_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
mul_zero, sub_self]
| _, States.inAsymp φ =>
| _, FieldOp.inAsymp φ =>
simp only [anPartF_negAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [crPartF_position, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.position φ, States.outAsymp φ' =>
| FieldOp.position φ, FieldOp.outAsymp φ' =>
simp only [crPartF_position, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.inAsymp φ, States.position φ' =>
| FieldOp.inAsymp φ, FieldOp.position φ' =>
simp only [crPartF_negAsymp, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.inAsymp φ, States.outAsymp φ' =>
| FieldOp.inAsymp φ, FieldOp.outAsymp φ' =>
simp only [crPartF_negAsymp, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
lemma superCommuteF_crPartF_crPartF (φ φ' : 𝓕.States) :
lemma superCommuteF_crPartF_crPartF (φ φ' : 𝓕.FieldOp) :
[crPartF φ, crPartF φ']ₛca = crPartF φ * crPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * crPartF φ := by
match φ, φ' with
| States.outAsymp φ, _ =>
| FieldOp.outAsymp φ, _ =>
simp only [crPartF_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
mul_zero, sub_self]
| _, States.outAsymp φ =>
| _, FieldOp.outAsymp φ =>
simp only [crPartF_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.position φ, States.inAsymp φ' =>
| FieldOp.position φ, FieldOp.inAsymp φ' =>
simp only [crPartF_position, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.inAsymp φ, States.position φ' =>
| FieldOp.inAsymp φ, FieldOp.position φ' =>
simp only [crPartF_negAsymp, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.inAsymp φ, States.inAsymp φ' =>
| FieldOp.inAsymp φ, FieldOp.inAsymp φ' =>
simp only [crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
lemma superCommuteF_anPartF_anPartF (φ φ' : 𝓕.States) :
lemma superCommuteF_anPartF_anPartF (φ φ' : 𝓕.FieldOp) :
[anPartF φ, anPartF φ']ₛca =
anPartF φ * anPartF φ' - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * anPartF φ := by
match φ, φ' with
| States.inAsymp φ, _ =>
| FieldOp.inAsymp φ, _ =>
simp
| _, States.inAsymp φ =>
| _, FieldOp.inAsymp φ =>
simp
| States.position φ, States.position φ' =>
| FieldOp.position φ, FieldOp.position φ' =>
simp only [anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.position φ, States.outAsymp φ' =>
| FieldOp.position φ, FieldOp.outAsymp φ' =>
simp only [anPartF_position, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.outAsymp φ, States.position φ' =>
| FieldOp.outAsymp φ, FieldOp.position φ' =>
simp only [anPartF_posAsymp, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
| States.outAsymp φ, States.outAsymp φ' =>
| FieldOp.outAsymp φ, FieldOp.outAsymp φ' =>
simp only [anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofCrAnListF]
simp [crAnStatistics, ← ofCrAnListF_append]
lemma superCommuteF_crPartF_ofFieldOpListF (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_crPartF_ofFieldOpListF (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[crPartF φ, ofFieldOpListF φs]ₛca =
crPartF φ * ofFieldOpListF φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpListF φs *
crPartF φ := by
match φ with
| States.inAsymp φ =>
| FieldOp.inAsymp φ =>
simp only [crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofFieldOpFsList]
simp [crAnStatistics]
| States.position φ =>
| FieldOp.position φ =>
simp only [crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofFieldOpFsList]
simp [crAnStatistics]
| States.outAsymp φ =>
| FieldOp.outAsymp φ =>
simp
lemma superCommuteF_anPartF_ofFieldOpListF (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_anPartF_ofFieldOpListF (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
[anPartF φ, ofFieldOpListF φs]ₛca =
anPartF φ * ofFieldOpListF φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) •
ofFieldOpListF φs * anPartF φ := by
match φ with
| States.inAsymp φ =>
| FieldOp.inAsymp φ =>
simp
| States.position φ =>
| FieldOp.position φ =>
simp only [anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofFieldOpFsList]
simp [crAnStatistics]
| States.outAsymp φ =>
| FieldOp.outAsymp φ =>
simp only [anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnListF_singleton, superCommuteF_ofCrAnListF_ofFieldOpFsList]
simp [crAnStatistics]
lemma superCommuteF_crPartF_ofFieldOpF (φ φ' : 𝓕.States) :
lemma superCommuteF_crPartF_ofFieldOpF (φ φ' : 𝓕.FieldOp) :
[crPartF φ, ofFieldOpF φ']ₛca =
crPartF φ * ofFieldOpF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOpF φ' * crPartF φ := by
rw [← ofFieldOpListF_singleton, superCommuteF_crPartF_ofFieldOpListF]
simp
lemma superCommuteF_anPartF_ofFieldOpF (φ φ' : 𝓕.States) :
lemma superCommuteF_anPartF_ofFieldOpF (φ φ' : 𝓕.FieldOp) :
[anPartF φ, ofFieldOpF φ']ₛca =
anPartF φ * ofFieldOpF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOpF φ' * anPartF φ := by
@ -256,44 +256,44 @@ Lemmas which rewrite a multiplication of two elements of the algebra as their co
multiplication with a sign plus the super commutor.
-/
lemma ofCrAnListF_mul_ofCrAnListF_eq_superCommuteF (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnListF_mul_ofCrAnListF_eq_superCommuteF (φs φs' : List 𝓕.CrAnFieldOp) :
ofCrAnListF φs * ofCrAnListF φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnListF φs' * ofCrAnListF φs
+ [ofCrAnListF φs, ofCrAnListF φs']ₛca := by
rw [superCommuteF_ofCrAnListF_ofCrAnListF]
simp [ofCrAnListF_append]
lemma ofCrAnOpF_mul_ofCrAnListF_eq_superCommuteF (φ : 𝓕.CrAnStates) (φs' : List 𝓕.CrAnStates) :
lemma ofCrAnOpF_mul_ofCrAnListF_eq_superCommuteF (φ : 𝓕.CrAnFieldOp) (φs' : List 𝓕.CrAnFieldOp) :
ofCrAnOpF φ * ofCrAnListF φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofCrAnListF φs' * ofCrAnOpF φ
+ [ofCrAnOpF φ, ofCrAnListF φs']ₛca := by
rw [← ofCrAnListF_singleton, ofCrAnListF_mul_ofCrAnListF_eq_superCommuteF]
simp
lemma ofFieldOpListF_mul_ofFieldOpListF_eq_superCommuteF (φs φs' : List 𝓕.States) :
lemma ofFieldOpListF_mul_ofFieldOpListF_eq_superCommuteF (φs φs' : List 𝓕.FieldOp) :
ofFieldOpListF φs * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofFieldOpListF φs
+ [ofFieldOpListF φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofFieldOpListF_ofFieldOpFsList]
simp
lemma ofFieldOpF_mul_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.States) (φs' : List 𝓕.States) :
lemma ofFieldOpF_mul_ofFieldOpListF_eq_superCommuteF (φ : 𝓕.FieldOp) (φs' : List 𝓕.FieldOp) :
ofFieldOpF φ * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofFieldOpF φ
+ [ofFieldOpF φ, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofFieldOpF_ofFieldOpFsList]
simp
lemma ofFieldOpListF_mul_ofFieldOpF_eq_superCommuteF (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma ofFieldOpListF_mul_ofFieldOpF_eq_superCommuteF (φs : List 𝓕.FieldOp) (φ : 𝓕.FieldOp) :
ofFieldOpListF φs * ofFieldOpF φ = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOpF φ * ofFieldOpListF φs
+ [ofFieldOpListF φs, ofFieldOpF φ]ₛca := by
rw [superCommuteF_ofFieldOpListF_ofFieldOpF]
simp
lemma crPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
lemma crPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.FieldOp) :
crPartF φ * anPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * crPartF φ +
[crPartF φ, anPartF φ']ₛca := by
rw [superCommuteF_crPartF_anPartF]
simp
lemma anPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
lemma anPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.FieldOp) :
anPartF φ * crPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
crPartF φ' * anPartF φ +
@ -301,20 +301,20 @@ lemma anPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
rw [superCommuteF_anPartF_crPartF]
simp
lemma crPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
lemma crPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.FieldOp) :
crPartF φ * crPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * crPartF φ +
[crPartF φ, crPartF φ']ₛca := by
rw [superCommuteF_crPartF_crPartF]
simp
lemma anPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
lemma anPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.FieldOp) :
anPartF φ * anPartF φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * anPartF φ +
[anPartF φ, anPartF φ']ₛca := by
rw [superCommuteF_anPartF_anPartF]
simp
lemma ofCrAnListF_mul_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnStates) (φs' : List 𝓕.States) :
lemma ofCrAnListF_mul_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnFieldOp) (φs' : List 𝓕.FieldOp) :
ofCrAnListF φs * ofFieldOpListF φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpListF φs' * ofCrAnListF φs
+ [ofCrAnListF φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofCrAnListF_ofFieldOpFsList]
@ -326,7 +326,7 @@ lemma ofCrAnListF_mul_ofFieldOpListF_eq_superCommuteF (φs : List 𝓕.CrAnState
-/
lemma superCommuteF_ofCrAnListF_ofCrAnListF_symm (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnListF_ofCrAnListF_symm (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs, ofCrAnListF φs']ₛca =
(- 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs')) • [ofCrAnListF φs', ofCrAnListF φs]ₛca := by
rw [superCommuteF_ofCrAnListF_ofCrAnListF, superCommuteF_ofCrAnListF_ofCrAnListF, smul_sub]
@ -338,7 +338,7 @@ lemma superCommuteF_ofCrAnListF_ofCrAnListF_symm (φs φs' : List 𝓕.CrAnState
simp only [one_smul]
abel
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF_symm (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF_symm (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnOpF φ, ofCrAnOpF φ']ₛca =
(- 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ')) • [ofCrAnOpF φ', ofCrAnOpF φ]ₛca := by
rw [superCommuteF_ofCrAnOpF_ofCrAnOpF, superCommuteF_ofCrAnOpF_ofCrAnOpF]
@ -357,7 +357,7 @@ lemma superCommuteF_ofCrAnOpF_ofCrAnOpF_symm (φ φ' : 𝓕.CrAnStates) :
-/
lemma superCommuteF_ofCrAnListF_ofCrAnListF_cons (φ : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnListF_ofCrAnListF_cons (φ : 𝓕.CrAnFieldOp) (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs, ofCrAnListF (φ :: φs')]ₛca =
[ofCrAnListF φs, ofCrAnOpF φ]ₛca * ofCrAnListF φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ)
@ -377,8 +377,8 @@ lemma superCommuteF_ofCrAnListF_ofCrAnListF_cons (φ : 𝓕.CrAnStates) (φs φs
rw [← ofCrAnListF_cons, smul_smul, FieldStatistic.ofList_cons_eq_mul]
simp only [instCommGroup, map_mul, mul_comm]
lemma superCommuteF_ofCrAnListF_ofFieldOpListF_cons (φ : 𝓕.States) (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnListF φs, ofFieldOpListF (φ :: φs')]ₛca =
lemma superCommuteF_ofCrAnListF_ofFieldOpListF_cons (φ : 𝓕.FieldOp) (φs : List 𝓕.CrAnFieldOp)
(φs' : List 𝓕.FieldOp) : [ofCrAnListF φs, ofFieldOpListF (φ :: φs')]ₛca =
[ofCrAnListF φs, ofFieldOpF φ]ₛca * ofFieldOpListF φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOpF φ * [ofCrAnListF φs, ofFieldOpListF φs']ₛca := by
rw [superCommuteF_ofCrAnListF_ofFieldOpFsList]
@ -402,8 +402,8 @@ Within the creation and annihilation algebra, we have that
`[φᶜᵃs, φᶜᵃ₀ … φᶜᵃₙ]ₛca = ∑ i, sᵢ • φᶜᵃs₀ … φᶜᵃᵢ₋₁ * [φᶜᵃs, φᶜᵃᵢ]ₛca * φᶜᵃᵢ₊₁ … φᶜᵃₙ`
where `sᵢ` is the exchange sign for `φᶜᵃs` and `φᶜᵃs₀ … φᶜᵃᵢ₋₁`.
-/
lemma superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum (φs : List 𝓕.CrAnStates) :
(φs' : List 𝓕.CrAnStates) → [ofCrAnListF φs, ofCrAnListF φs']ₛca =
lemma superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum (φs : List 𝓕.CrAnFieldOp) :
(φs' : List 𝓕.CrAnFieldOp) → [ofCrAnListF φs, ofCrAnListF φs']ₛca =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofCrAnListF (φs'.take n) * [ofCrAnListF φs, ofCrAnOpF (φs'.get n)]ₛca *
ofCrAnListF (φs'.drop (n + 1))
@ -417,7 +417,7 @@ lemma superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum (φs : List 𝓕.CrAnStates)
· simp [Finset.mul_sum, smul_smul, ofCrAnListF_cons, mul_assoc,
FieldStatistic.ofList_cons_eq_mul, mul_comm]
lemma superCommuteF_ofCrAnListF_ofFieldOpListF_eq_sum (φs : List 𝓕.CrAnStates) : (φs' : List 𝓕.States) →
lemma superCommuteF_ofCrAnListF_ofFieldOpListF_eq_sum (φs : List 𝓕.CrAnFieldOp) : (φs' : List 𝓕.FieldOp) →
[ofCrAnListF φs, ofFieldOpListF φs']ₛca =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofFieldOpListF (φs'.take n) * [ofCrAnListF φs, ofFieldOpF (φs'.get n)]ₛca *
@ -436,7 +436,7 @@ lemma superCommuteF_ofCrAnListF_ofFieldOpListF_eq_sum (φs : List 𝓕.CrAnState
· simp [Finset.mul_sum, smul_smul, ofFieldOpListF_cons, mul_assoc,
FieldStatistic.ofList_cons_eq_mul, mul_comm]
lemma summerCommute_jacobi_ofCrAnListF (φs1 φs2 φs3 : List 𝓕.CrAnStates) :
lemma summerCommute_jacobi_ofCrAnListF (φs1 φs2 φs3 : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs1, [ofCrAnListF φs2, ofCrAnListF φs3]ₛca]ₛca =
𝓢(𝓕 |>ₛ φs1, 𝓕 |>ₛ φs3) •
(- 𝓢(𝓕 |>ₛ φs2, 𝓕 |>ₛ φs3) • [ofCrAnListF φs3, [ofCrAnListF φs1, ofCrAnListF φs2]ₛca]ₛca -
@ -706,7 +706,7 @@ lemma superCommuteF_expand_bosonicProj_fermionicProj (a b : 𝓕.FieldOpFreeAlge
superCommuteF_fermionic_fermionic (by simp) (by simp)]
abel
lemma superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic (φs φs' : List 𝓕.CrAnFieldOp) :
[ofCrAnListF φs, ofCrAnListF φs']ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnListF φs, ofCrAnListF φs']ₛca ∈ statisticSubmodule fermionic := by
by_cases h1 : (𝓕 |>ₛ φs) = bosonic <;> by_cases h2 : (𝓕 |>ₛ φs') = bosonic
@ -743,13 +743,13 @@ lemma superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic (φs φs' : Lis
apply ofCrAnListF_mem_statisticSubmodule_of _ _ (by simpa using h1)
apply ofCrAnListF_mem_statisticSubmodule_of _ _ (by simpa using h2)
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_fermionic (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_fermionic (φ φ' : 𝓕.CrAnFieldOp) :
[ofCrAnOpF φ, ofCrAnOpF φ']ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnOpF φ, ofCrAnOpF φ']ₛca ∈ statisticSubmodule fermionic := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
exact superCommuteF_ofCrAnListF_ofCrAnListF_bosonic_or_fermionic [φ] [φ']
lemma superCommuteF_superCommuteF_ofCrAnOpF_bosonic_or_fermionic (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma superCommuteF_superCommuteF_ofCrAnOpF_bosonic_or_fermionic (φ1 φ2 φ3 : 𝓕.CrAnFieldOp) :
[ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca ∈ statisticSubmodule fermionic := by
rcases superCommuteF_ofCrAnOpF_ofCrAnOpF_bosonic_or_fermionic φ2 φ3 with hs | hs
@ -779,7 +779,7 @@ lemma superCommuteF_superCommuteF_ofCrAnOpF_bosonic_or_fermionic (φ1 φ2 φ3 :
rw [h]
apply superCommuteF_grade h1 hs
lemma superCommuteF_bosonic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (φs : List 𝓕.CrAnStates)
lemma superCommuteF_bosonic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (φs : List 𝓕.CrAnFieldOp)
(ha : a ∈ statisticSubmodule bosonic) :
[a, ofCrAnListF φs]ₛca = ∑ (n : Fin φs.length),
ofCrAnListF (φs.take n) * [a, ofCrAnOpF (φs.get n)]ₛca *
@ -808,7 +808,7 @@ lemma superCommuteF_bosonic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (φ
simp_all [p, Finset.smul_sum]
· exact ha
lemma superCommuteF_fermionic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (φs : List 𝓕.CrAnStates)
lemma superCommuteF_fermionic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (φs : List 𝓕.CrAnFieldOp)
(ha : a ∈ statisticSubmodule fermionic) :
[a, ofCrAnListF φs]ₛca = ∑ (n : Fin φs.length), 𝓢(fermionic, 𝓕 |>ₛ φs.take n) •
ofCrAnListF (φs.take n) * [a, ofCrAnOpF (φs.get n)]ₛca *
@ -842,7 +842,7 @@ lemma superCommuteF_fermionic_ofCrAnListF_eq_sum (a : 𝓕.FieldOpFreeAlgebra) (
simp [smul_smul, mul_comm]
· exact ha
lemma statistic_neq_of_superCommuteF_fermionic {φs φs' : List 𝓕.CrAnStates}
lemma statistic_neq_of_superCommuteF_fermionic {φs φs' : List 𝓕.CrAnFieldOp}
(h : [ofCrAnListF φs, ofCrAnListF φs']ₛca ∈ statisticSubmodule fermionic) :
(𝓕 |>ₛ φs) ≠ (𝓕 |>ₛ φs') ∨ [ofCrAnListF φs, ofCrAnListF φs']ₛca = 0 := by
by_cases h0 : [ofCrAnListF φs, ofCrAnListF φs']ₛca = 0

34
HepLean/PerturbationTheory/Algebras/FieldOpFreeAlgebra/TimeOrder.lean
View file

@ -34,7 +34,7 @@ def timeOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕 :=
@[inherit_doc timeOrderF]
scoped[FieldSpecification.FieldOpFreeAlgebra] notation "𝓣ᶠ(" a ")" => timeOrderF a
lemma timeOrderF_ofCrAnListF (φs : List 𝓕.CrAnStates) :
lemma timeOrderF_ofCrAnListF (φs : List 𝓕.CrAnFieldOp) :
𝓣ᶠ(ofCrAnListF φs) = crAnTimeOrderSign φs • ofCrAnListF (crAnTimeOrderList φs) := by
rw [← ofListBasis_eq_ofList]
simp only [timeOrderF, Basis.constr_basis]
@ -99,7 +99,7 @@ lemma timeOrderF_timeOrderF_left (a b : 𝓕.FieldOpFreeAlgebra) : 𝓣ᶠ(a * b
· rw [timeOrderF_timeOrderF_mid]
simp
lemma timeOrderF_ofFieldOpListF (φs : List 𝓕.States) :
lemma timeOrderF_ofFieldOpListF (φs : List 𝓕.FieldOp) :
𝓣ᶠ(ofFieldOpListF φs) = timeOrderSign φs • ofFieldOpListF (timeOrderList φs) := by
conv_lhs =>
rw [ofFieldOpListF_sum, map_sum]
@ -116,10 +116,10 @@ lemma timeOrderF_ofFieldOpListF_nil : timeOrderF (𝓕 := 𝓕) (ofFieldOpListF
simp [timeOrderSign, Wick.koszulSign, timeOrderList]
@[simp]
lemma timeOrderF_ofFieldOpListF_singleton (φ : 𝓕.States) : 𝓣ᶠ(ofFieldOpListF [φ]) = ofFieldOpListF [φ] := by
lemma timeOrderF_ofFieldOpListF_singleton (φ : 𝓕.FieldOp) : 𝓣ᶠ(ofFieldOpListF [φ]) = ofFieldOpListF [φ] := by
simp [timeOrderF_ofFieldOpListF, timeOrderSign, timeOrderList]
lemma timeOrderF_ofFieldOpF_ofFieldOpF_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
lemma timeOrderF_ofFieldOpF_ofFieldOpF_ordered {φ ψ : 𝓕.FieldOp} (h : timeOrderRel φ ψ) :
𝓣ᶠ(ofFieldOpF φ * ofFieldOpF ψ) = ofFieldOpF φ * ofFieldOpF ψ := by
rw [← ofFieldOpListF_singleton, ← ofFieldOpListF_singleton, ← ofFieldOpListF_append,
timeOrderF_ofFieldOpListF]
@ -127,7 +127,7 @@ lemma timeOrderF_ofFieldOpF_ofFieldOpF_ordered {φ ψ : 𝓕.States} (h : timeOr
rw [timeOrderSign_pair_ordered h, timeOrderList_pair_ordered h]
simp
lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered {φ ψ : 𝓕.FieldOp} (h : ¬ timeOrderRel φ ψ) :
𝓣ᶠ(ofFieldOpF φ * ofFieldOpF ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • ofFieldOpF ψ * ofFieldOpF φ := by
rw [← ofFieldOpListF_singleton, ← ofFieldOpListF_singleton,
← ofFieldOpListF_append, timeOrderF_ofFieldOpListF]
@ -135,7 +135,7 @@ lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered {φ ψ : 𝓕.States} (h : ¬
rw [timeOrderSign_pair_not_ordered h, timeOrderList_pair_not_ordered h]
simp [← ofFieldOpListF_append]
lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered_eq_timeOrderF {φ ψ : 𝓕.States}
lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered_eq_timeOrderF {φ ψ : 𝓕.FieldOp}
(h : ¬ timeOrderRel φ ψ) :
𝓣ᶠ(ofFieldOpF φ * ofFieldOpF ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • 𝓣ᶠ(ofFieldOpF ψ * ofFieldOpF φ) := by
rw [timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered h]
@ -145,7 +145,7 @@ lemma timeOrderF_ofFieldOpF_ofFieldOpF_not_ordered_eq_timeOrderF {φ ψ : 𝓕.S
simp_all
lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) :
{φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) :
𝓣ᶠ([ofCrAnOpF φ, ofCrAnOpF ψ]ₛca) = 0 := by
rw [superCommuteF_ofCrAnOpF_ofCrAnOpF]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, map_sub, map_smul]
@ -163,28 +163,28 @@ lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel
simp_all
lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel_right
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.FieldOpFreeAlgebra) :
{φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.FieldOpFreeAlgebra) :
𝓣ᶠ(a * [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca) = 0 := by
rw [timeOrderF_timeOrderF_right,
timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel h]
simp
lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel_left
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.FieldOpFreeAlgebra) :
{φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.FieldOpFreeAlgebra) :
𝓣ᶠ([ofCrAnOpF φ, ofCrAnOpF ψ]ₛca * a) = 0 := by
rw [timeOrderF_timeOrderF_left,
timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel h]
simp
lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel_mid
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a b : 𝓕.FieldOpFreeAlgebra) :
{φ ψ : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ ψ) (a b : 𝓕.FieldOpFreeAlgebra) :
𝓣ᶠ(a * [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca * b) = 0 := by
rw [timeOrderF_timeOrderF_mid,
timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_not_crAnTimeOrderRel h]
simp
lemma timeOrderF_superCommuteF_superCommuteF_ofCrAnOpF_not_crAnTimeOrderRel
{φ1 φ2 : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ1 φ2) (a : 𝓕.FieldOpFreeAlgebra) :
{φ1 φ2 : 𝓕.CrAnFieldOp} (h : ¬ crAnTimeOrderRel φ1 φ2) (a : 𝓕.FieldOpFreeAlgebra) :
𝓣ᶠ([a, [ofCrAnOpF φ1, ofCrAnOpF φ2]ₛca]ₛca) = 0 := by
rw [← bosonicProj_add_fermionicProj a]
simp only [map_add, LinearMap.add_apply]
@ -207,7 +207,7 @@ lemma timeOrderF_superCommuteF_superCommuteF_ofCrAnOpF_not_crAnTimeOrderRel
simp
lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_not_crAnTimeOrderRel
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ1 φ2)
{φ1 φ2 φ3 : 𝓕.CrAnFieldOp} (h12 : ¬ crAnTimeOrderRel φ1 φ2)
(h13 : ¬ crAnTimeOrderRel φ1 φ3) :
𝓣ᶠ([ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca) = 0 := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
@ -223,7 +223,7 @@ lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_not_crAnTimeOrderRel
simp
lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_not_crAnTimeOrderRel'
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ2 φ1)
{φ1 φ2 φ3 : 𝓕.CrAnFieldOp} (h12 : ¬ crAnTimeOrderRel φ2 φ1)
(h13 : ¬ crAnTimeOrderRel φ3 φ1) :
𝓣ᶠ([ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛca]ₛca) = 0 := by
rw [← ofCrAnListF_singleton, ← ofCrAnListF_singleton, ← ofCrAnListF_singleton]
@ -239,7 +239,7 @@ lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_not_crAnTimeOrderRel'
simp
lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_all_not_crAnTimeOrderRel
(φ1 φ2 φ3 : 𝓕.CrAnStates) (h : ¬
(φ1 φ2 φ3 : 𝓕.CrAnFieldOp) (h : ¬
(crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
crAnTimeOrderRel φ3 φ1 ∧ crAnTimeOrderRel φ3 φ2)) :
@ -277,7 +277,7 @@ lemma timeOrderF_superCommuteF_ofCrAnOpF_superCommuteF_all_not_crAnTimeOrderRel
exact IsTrans.trans φ3 φ2 φ1 h32 h21
lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_eq_time
{φ ψ : 𝓕.CrAnStates} (h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) :
{φ ψ : 𝓕.CrAnFieldOp} (h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) :
𝓣ᶠ([ofCrAnOpF φ, ofCrAnOpF ψ]ₛca) = [ofCrAnOpF φ, ofCrAnOpF ψ]ₛca := by
rw [superCommuteF_ofCrAnOpF_ofCrAnOpF]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, map_sub, map_smul]
@ -297,7 +297,7 @@ lemma timeOrderF_superCommuteF_ofCrAnOpF_ofCrAnOpF_eq_time
/-- In the state algebra time, ordering obeys `T(φ₀φ₁…φₙ) = s * φᵢ * T(φ₀φ₁…φᵢ₋₁φᵢ₊₁…φₙ)`
where `φᵢ` is the state
which has maximum time and `s` is the exchange sign of `φᵢ` and `φ₀φ₁…φᵢ₋₁`. -/
lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
𝓣ᶠ(ofFieldOpListF (φ :: φs)) =
𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ (φ :: φs).take (maxTimeFieldPos φ φs)) •
ofFieldOpF (maxTimeField φ φs) * 𝓣ᶠ(ofFieldOpListF (eraseMaxTimeField φ φs)) := by
@ -312,7 +312,7 @@ lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States)
where `φᵢ` is the state
which has maximum time and `s` is the exchange sign of `φᵢ` and `φ₀φ₁…φᵢ₋₁`.
Here `s` is written using finite sets. -/
lemma timeOrderF_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma timeOrderF_eq_maxTimeField_mul_finset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) :
𝓣ᶠ(ofFieldOpListF (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
(Finset.filter (fun x =>
(maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs) Finset.univ)⟩) •

30
HepLean/PerturbationTheory/FieldSpecification/Basic.lean
View file

@ -16,7 +16,7 @@ In this module is the definition of a field specification.
A field specification is a structure consisting of a type of fields and a
the field statistics of each field.
From each field we can create three different types of `States`.
From each field we can create three different types of `FieldOp`.
- Negative asymptotic states.
- Position states.
- Positive asymptotic states.
@ -52,27 +52,27 @@ def IncomingAsymptotic : Type := 𝓕.Fields × Lorentz.Contr 4
def OutgoingAsymptotic : Type := 𝓕.Fields × Lorentz.Contr 4
/-- A position state is a field and a space-time position. -/
def PositionStates : Type := 𝓕.Fields × SpaceTime
def PositionFieldOp : Type := 𝓕.Fields × SpaceTime
/-- The type States is the inductive type combining the asymptotic states and position states. -/
inductive States (𝓕 : FieldSpecification) where
| inAsymp : 𝓕.IncomingAsymptotic → 𝓕.States
| position : 𝓕.PositionStates → 𝓕.States
| outAsymp : 𝓕.OutgoingAsymptotic → 𝓕.States
/-- The type FieldOp is the inductive type combining the asymptotic states and position states. -/
inductive FieldOp (𝓕 : FieldSpecification) where
| inAsymp : 𝓕.IncomingAsymptotic → 𝓕.FieldOp
| position : 𝓕.PositionFieldOp → 𝓕.FieldOp
| outAsymp : 𝓕.OutgoingAsymptotic → 𝓕.FieldOp
/-- Taking a state to its underlying field. -/
def statesToField : 𝓕.States → 𝓕.Fields
| States.inAsymp φ => φ.1
| States.position φ => φ.1
| States.outAsymp φ => φ.1
def fieldOpToField : 𝓕.FieldOp → 𝓕.Fields
| FieldOp.inAsymp φ => φ.1
| FieldOp.position φ => φ.1
| FieldOp.outAsymp φ => φ.1
/-- The bool on `States` which is true only for position states. -/
def statesIsPosition : 𝓕.States → Bool
| States.position _ => true
/-- The bool on `FieldOp` which is true only for position states. -/
def statesIsPosition : 𝓕.FieldOp → Bool
| FieldOp.position _ => true
| _ => false
/-- The statistics associated to a state. -/
def statesStatistic : 𝓕.States → FieldStatistic := 𝓕.statistics ∘ 𝓕.statesToField
def statesStatistic : 𝓕.FieldOp → FieldStatistic := 𝓕.statistics ∘ 𝓕.fieldOpToField
/-- The field statistics associated with a state. -/
scoped[FieldSpecification] notation 𝓕 "|>ₛ" φ => statesStatistic 𝓕 φ

102
HepLean/PerturbationTheory/FieldSpecification/CrAnFieldOp.lean Normal file
View file

@ -0,0 +1,102 @@
/-
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.FieldSpecification.Basic
import HepLean.PerturbationTheory.CreateAnnihilate
/-!
# Creation and annihilation states
Called `CrAnFieldOp` for short here.
Given a field specification, in addition to defining states
(see: `HepLean.PerturbationTheory.FieldSpecification.Basic`),
we can also define creation and annihilation states.
These are similar to states but come with an additional specification of whether they correspond to
creation or annihilation operators.
In particular we have the following creation and annihilation states for each field:
- Negative asymptotic states - with the implicit specification that it is a creation state.
- Position states with a creation specification.
- Position states with an annihilation specification.
- Positive asymptotic states - with the implicit specification that it is an annihilation state.
In this module in addition to defining `CrAnFieldOp` we also define some maps:
- The map `crAnFieldOpToFieldOp` takes a `CrAnFieldOp` to its state in `FieldOp`.
- The map `crAnFieldOpToCreateAnnihilate` takes a `CrAnFieldOp` to its corresponding
`CreateAnnihilate` value.
- The map `crAnStatistics` takes a `CrAnFieldOp` to its corresponding `FieldStatistic`
(bosonic or fermionic).
-/
namespace FieldSpecification
variable (𝓕 : FieldSpecification)
/-- To each state the specificaition of the type of creation and annihlation parts.
For asymptotic staes there is only one allowed part, whilst for position states
there is two. -/
def fieldOpToCrAnType : 𝓕.FieldOp → Type
| FieldOp.inAsymp _ => Unit
| FieldOp.position _ => CreateAnnihilate
| FieldOp.outAsymp _ => Unit
/-- The instance of a finite type on `𝓕.fieldOpToCreateAnnihilateType i`. -/
instance : ∀ i, Fintype (𝓕.fieldOpToCrAnType i) := fun i =>
match i with
| FieldOp.inAsymp _ => inferInstanceAs (Fintype Unit)
| FieldOp.position _ => inferInstanceAs (Fintype CreateAnnihilate)
| FieldOp.outAsymp _ => inferInstanceAs (Fintype Unit)
/-- The instance of a decidable equality on `𝓕.fieldOpToCreateAnnihilateType i`. -/
instance : ∀ i, DecidableEq (𝓕.fieldOpToCrAnType i) := fun i =>
match i with
| FieldOp.inAsymp _ => inferInstanceAs (DecidableEq Unit)
| FieldOp.position _ => inferInstanceAs (DecidableEq CreateAnnihilate)
| FieldOp.outAsymp _ => inferInstanceAs (DecidableEq Unit)
/-- The equivalence between `𝓕.fieldOpToCreateAnnihilateType i` and
`𝓕.fieldOpToCreateAnnihilateType j` from an equality `i = j`. -/
def fieldOpToCreateAnnihilateTypeCongr : {i j : 𝓕.FieldOp} → i = j →
𝓕.fieldOpToCrAnType i ≃ 𝓕.fieldOpToCrAnType j
| _, _, rfl => Equiv.refl _
/-- A creation and annihlation state is a state plus an valid specification of the
creation or annihliation part of that state. (For asympotic states there is only one valid
choice). -/
def CrAnFieldOp : Type := Σ (s : 𝓕.FieldOp), 𝓕.fieldOpToCrAnType s
/-- The map from creation and annihlation states to their underlying states. -/
def crAnFieldOpToFieldOp : 𝓕.CrAnFieldOp → 𝓕.FieldOp := Sigma.fst
@[simp]
lemma crAnFieldOpToFieldOp_prod (s : 𝓕.FieldOp) (t : 𝓕.fieldOpToCrAnType s) :
𝓕.crAnFieldOpToFieldOp ⟨s, t⟩ = s := rfl
/-- The map from creation and annihlation states to the type `CreateAnnihilate`
specifying if a state is a creation or an annihilation state. -/
def crAnFieldOpToCreateAnnihilate : 𝓕.CrAnFieldOp → CreateAnnihilate
| ⟨FieldOp.inAsymp _, _⟩ => CreateAnnihilate.create
| ⟨FieldOp.position _, CreateAnnihilate.create⟩ => CreateAnnihilate.create
| ⟨FieldOp.position _, CreateAnnihilate.annihilate⟩ => CreateAnnihilate.annihilate
| ⟨FieldOp.outAsymp _, _⟩ => CreateAnnihilate.annihilate
/-- Takes a `CrAnFieldOp` state to its corresponding fields statistic (bosonic or fermionic). -/
def crAnStatistics : 𝓕.CrAnFieldOp → FieldStatistic :=
𝓕.statesStatistic ∘ 𝓕.crAnFieldOpToFieldOp
/-- The field statistic of a `CrAnState`. -/
scoped[FieldSpecification] notation 𝓕 "|>ₛ" φ =>
(crAnStatistics 𝓕) φ
/-- The field statistic of a list of `CrAnState`s. -/
scoped[FieldSpecification] notation 𝓕 "|>ₛ" φ => FieldStatistic.ofList
(crAnStatistics 𝓕) φ
/-- The `CreateAnnihilate` value of a `CrAnState`s, i.e. whether it is a creation or
annihilation operator. -/
scoped[FieldSpecification] infixl:80 "|>ᶜ" =>
crAnFieldOpToCreateAnnihilate
end FieldSpecification

130
HepLean/PerturbationTheory/FieldSpecification/CrAnSection.lean
View file

@ -3,7 +3,7 @@ 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.FieldSpecification.CrAnStates
import HepLean.PerturbationTheory.FieldSpecification.CrAnFieldOp
/-!
# Creation and annihlation sections
@ -11,13 +11,13 @@ import HepLean.PerturbationTheory.FieldSpecification.CrAnStates
In the module
`HepLean.PerturbationTheory.FieldSpecification.Basic`
we defined states for a field specification, and in the module
`HepLean.PerturbationTheory.FieldStatistics.CrAnStates`
we defined a refinement of states called `CrAnStates` which distinquishes between the
`HepLean.PerturbationTheory.FieldStatistics.CrAnFieldOp`
we defined a refinement of states called `CrAnFieldOp` which distinquishes between the
creation and annihilation components of states.
There exists, in particular, a map from `CrAnStates` to `States` called `crAnStatesToStates`.
There exists, in particular, a map from `CrAnFieldOp` to `FieldOp` called `crAnFieldOpToFieldOp`.
Given a list of `States`, `φs`, in this module we define a section of `φs` to be a list of
`CrAnStates`, `ψs`, such that under the map `crAnStatesToStates`, `ψs` is mapped to `φs`.
Given a list of `FieldOp`, `φs`, in this module we define a section of `φs` to be a list of
`CrAnFieldOp`, `ψs`, such that under the map `crAnFieldOpToFieldOp`, `ψs` is mapped to `φs`.
That is to say, the states underlying `ψs` are the states in `φs`.
We denote these sections as `CrAnSection φs`.
@ -31,30 +31,30 @@ In this module we define various properties of `CrAnSection`.
namespace FieldSpecification
variable {𝓕 : FieldSpecification}
/-- The sections in `𝓕.CrAnStates` over a list `φs : List 𝓕.States`.
/-- The sections in `𝓕.CrAnFieldOp` over a list `φs : List 𝓕.FieldOp`.
In terms of physics, given some fields `φ₁...φₙ`, the different ways one can associate
each field as a `creation` or an `annilation` operator. E.g. the number of terms
`φ₁⁰φ₂¹...φₙ⁰` `φ₁¹φ₂¹...φₙ⁰` etc. If some fields are exclusively creation or annhilation
operators at this point (e.g. ansymptotic states) this is accounted for. -/
def CrAnSection (φs : List 𝓕.States) : Type :=
{ψs : List 𝓕.CrAnStates // ψs.map 𝓕.crAnStatesToStates = φs}
-- Π i, 𝓕.statesToCreateAnnihilateType (φs.get i)
def CrAnSection (φs : List 𝓕.FieldOp) : Type :=
{ψs : List 𝓕.CrAnFieldOp // ψs.map 𝓕.crAnFieldOpToFieldOp = φs}
-- Π i, 𝓕.fieldOpToCreateAnnihilateType (φs.get i)
namespace CrAnSection
open FieldStatistic
variable {𝓕 : FieldSpecification} {φs : List 𝓕.States}
variable {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp}
@[simp]
lemma length_eq (ψs : CrAnSection φs) : ψs.1.length = φs.length := by
simpa using congrArg List.length ψs.2
/-- The tail of a section for `φs`. -/
def tail : {φs : List 𝓕.States} → (ψs : CrAnSection φs) → CrAnSection φs.tail
def tail : {φs : List 𝓕.FieldOp} → (ψs : CrAnSection φs) → CrAnSection φs.tail
| [], ⟨[], h⟩ => ⟨[], h⟩
| φ :: φs, ⟨[], h⟩ => False.elim (by simp at h)
| φ :: φs, ⟨ψ :: ψs, h⟩ => ⟨ψs, by rw [List.map_cons, List.cons.injEq] at h; exact h.2⟩
lemma head_state_eq {φ : 𝓕.States} : (ψs : CrAnSection (φ :: φs)) →
lemma head_state_eq {φ : 𝓕.FieldOp} : (ψs : CrAnSection (φ :: φs)) →
(ψs.1.head (by simp [← List.length_pos_iff_ne_nil])).1 = φ
| ⟨[], h⟩ => False.elim (by simp at h)
| ⟨ψ :: ψs, h⟩ => by
@ -72,14 +72,14 @@ lemma take_statistics_eq_take_state_statistics (ψs : CrAnSection φs) n :
simp only [instCommGroup, List.map_take]
rw [← List.map_comp_map, Function.comp_apply, ψs.2]
/-- The head of a section for `φ :: φs` as an element in `𝓕.statesToCreateAnnihilateType φ`. -/
def head : {φ : 𝓕.States} → (ψs : CrAnSection (φ :: φs)) →
𝓕.statesToCrAnType φ
/-- The head of a section for `φ :: φs` as an element in `𝓕.fieldOpToCreateAnnihilateType φ`. -/
def head : {φ : 𝓕.FieldOp} → (ψs : CrAnSection (φ :: φs)) →
𝓕.fieldOpToCrAnType φ
| φ, ⟨[], h⟩ => False.elim (by simp at h)
| φ, ⟨ψ :: ψs, h⟩ => 𝓕.statesToCreateAnnihilateTypeCongr (by
| φ, ⟨ψ :: ψs, h⟩ => 𝓕.fieldOpToCreateAnnihilateTypeCongr (by
simpa using head_state_eq ⟨ψ :: ψs, h⟩) ψ.2
lemma eq_head_cons_tail {φ : 𝓕.States} {ψs : CrAnSection (φ :: φs)} :
lemma eq_head_cons_tail {φ : 𝓕.FieldOp} {ψs : CrAnSection (φ :: φs)} :
ψs.1 = ⟨φ, head ψs⟩ :: ψs.tail.1 := by
match ψs with
| ⟨[], h⟩ => exact False.elim (by simp at h)
@ -90,13 +90,13 @@ lemma eq_head_cons_tail {φ : 𝓕.States} {ψs : CrAnSection (φ :: φs)} :
rfl
/-- The creation of a section from for `φ : φs` from a section for `φs` and a
element of `𝓕.statesToCreateAnnihilateType φ`. -/
def cons {φ : 𝓕.States} (ψ : 𝓕.statesToCrAnType φ) (ψs : CrAnSection φs) :
element of `𝓕.fieldOpToCreateAnnihilateType φ`. -/
def cons {φ : 𝓕.FieldOp} (ψ : 𝓕.fieldOpToCrAnType φ) (ψs : CrAnSection φs) :
CrAnSection (φ :: φs) := ⟨⟨φ, ψ⟩ :: ψs.1, by
simp [List.map_cons, ψs.2]⟩
/-- For the empty list of states there is only one `CrAnSection`. Corresponding to the
empty list of `CrAnStates`. -/
empty list of `CrAnFieldOp`. -/
def nilEquiv : CrAnSection (𝓕 := 𝓕) [] ≃ Unit where
toFun _ := ()
invFun _ := ⟨[], rfl⟩
@ -108,10 +108,10 @@ def nilEquiv : CrAnSection (𝓕 := 𝓕) [] ≃ Unit where
simp
/-- The creation and annihlation sections for a singleton list is given by
a choice of `𝓕.statesToCreateAnnihilateType φ`. If `φ` is a asymptotic state
a choice of `𝓕.fieldOpToCreateAnnihilateType φ`. If `φ` is a asymptotic state
there is no choice here, else there are two choices. -/
def singletonEquiv {φ : 𝓕.States} : CrAnSection [φ] ≃
𝓕.statesToCrAnType φ where
def singletonEquiv {φ : 𝓕.FieldOp} : CrAnSection [φ] ≃
𝓕.fieldOpToCrAnType φ where
toFun ψs := ψs.head
invFun ψ := ⟨[⟨φ, ψ⟩], by simp⟩
left_inv ψs := by
@ -128,8 +128,8 @@ def singletonEquiv {φ : 𝓕.States} : CrAnSection [φ] ≃
/-- An equivalence seperating the head of a creation and annhilation section
from the tail. -/
def consEquiv {φ : 𝓕.States} {φs : List 𝓕.States} : CrAnSection (φ :: φs) ≃
𝓕.statesToCrAnType φ × CrAnSection φs where
def consEquiv {φ : 𝓕.FieldOp} {φs : List 𝓕.FieldOp} : CrAnSection (φ :: φs) ≃
𝓕.fieldOpToCrAnType φ × CrAnSection φs where
toFun ψs := ⟨ψs.head, ψs.tail⟩
invFun ψψs :=
match ψψs with
@ -143,7 +143,7 @@ def consEquiv {φ : 𝓕.States} {φs : List 𝓕.States} : CrAnSection (φ ::
/-- The instance of a finite type on `CrAnSection`s defined recursively through
`consEquiv`. -/
instance fintype : (φs : List 𝓕.States) → Fintype (CrAnSection φs)
instance fintype : (φs : List 𝓕.FieldOp) → Fintype (CrAnSection φs)
| [] => Fintype.ofEquiv _ nilEquiv.symm
| _ :: φs =>
haveI : Fintype (CrAnSection φs) := fintype φs
@ -154,34 +154,34 @@ lemma card_nil_eq : Fintype.card (CrAnSection (𝓕 := 𝓕) []) = 1 := by
rw [Fintype.ofEquiv_card nilEquiv.symm]
simp
lemma card_cons_eq {φ : 𝓕.States} {φs : List 𝓕.States} :
Fintype.card (CrAnSection (φ :: φs)) = Fintype.card (𝓕.statesToCrAnType φ) *
lemma card_cons_eq {φ : 𝓕.FieldOp} {φs : List 𝓕.FieldOp} :
Fintype.card (CrAnSection (φ :: φs)) = Fintype.card (𝓕.fieldOpToCrAnType φ) *
Fintype.card (CrAnSection φs) := by
rw [Fintype.ofEquiv_card consEquiv.symm]
simp
lemma card_eq_mul : {φs : List 𝓕.States} → Fintype.card (CrAnSection φs) =
lemma card_eq_mul : {φs : List 𝓕.FieldOp} → Fintype.card (CrAnSection φs) =
2 ^ (List.countP 𝓕.statesIsPosition φs)
| [] => by
simp
| States.position _ :: φs => by
| FieldOp.position _ :: φs => by
simp only [statesIsPosition, List.countP_cons_of_pos]
rw [card_cons_eq]
rw [card_eq_mul]
simp only [statesToCrAnType, CreateAnnihilate.CreateAnnihilate_card_eq_two]
simp only [fieldOpToCrAnType, CreateAnnihilate.CreateAnnihilate_card_eq_two]
ring
| States.inAsymp x_ :: φs => by
| FieldOp.inAsymp x_ :: φs => by
simp only [statesIsPosition, Bool.false_eq_true, not_false_eq_true, List.countP_cons_of_neg]
rw [card_cons_eq]
rw [card_eq_mul]
simp [statesToCrAnType]
| States.outAsymp _ :: φs => by
simp [fieldOpToCrAnType]
| FieldOp.outAsymp _ :: φs => by
simp only [statesIsPosition, Bool.false_eq_true, not_false_eq_true, List.countP_cons_of_neg]
rw [card_cons_eq]
rw [card_eq_mul]
simp [statesToCrAnType]
simp [fieldOpToCrAnType]
lemma card_perm_eq {φs φs' : List 𝓕.States} (h : φs.Perm φs') :
lemma card_perm_eq {φs φs' : List 𝓕.FieldOp} (h : φs.Perm φs') :
Fintype.card (CrAnSection φs) = Fintype.card (CrAnSection φs') := by
rw [card_eq_mul, card_eq_mul]
congr 1
@ -195,7 +195,7 @@ lemma sum_nil (f : CrAnSection (𝓕 := 𝓕) [] → M) [AddCommMonoid M] :
rfl
lemma sum_cons (f : CrAnSection (φ :: φs) → M) [AddCommMonoid M] :
∑ (s : CrAnSection (φ :: φs)), f s = ∑ (a : 𝓕.statesToCrAnType φ),
∑ (s : CrAnSection (φ :: φs)), f s = ∑ (a : 𝓕.fieldOpToCrAnType φ),
∑ (s : CrAnSection φs), f (cons a s) := by
rw [← consEquiv.symm.sum_comp, Fintype.sum_prod_type]
rfl
@ -208,24 +208,24 @@ lemma sum_over_length {s : CrAnSection φs} (f : Fin s.1.length → M)
/-- The equivalence between `CrAnSection φs` and
`CrAnSection φs'` induced by an equality `φs = φs'`. -/
def congr : {φs φs' : List 𝓕.States} → (h : φs = φs') →
def congr : {φs φs' : List 𝓕.FieldOp} → (h : φs = φs') →
CrAnSection φs ≃ CrAnSection φs'
| _, _, rfl => Equiv.refl _
@[simp]
lemma congr_fst {φs φs' : List 𝓕.States} (h : φs = φs') (ψs : CrAnSection φs) :
lemma congr_fst {φs φs' : List 𝓕.FieldOp} (h : φs = φs') (ψs : CrAnSection φs) :
(congr h ψs).1 = ψs.1 := by
cases h
rfl
@[simp]
lemma congr_symm {φs φs' : List 𝓕.States} (h : φs = φs') :
lemma congr_symm {φs φs' : List 𝓕.FieldOp} (h : φs = φs') :
(congr h).symm = congr h.symm := by
cases h
rfl
@[simp]
lemma congr_trans_apply {φs φs' φs'' : List 𝓕.States} (h1 : φs = φs') (h2 : φs' = φs'')
lemma congr_trans_apply {φs φs' φs'' : List 𝓕.FieldOp} (h1 : φs = φs') (h2 : φs' = φs'')
(ψs : CrAnSection φs) :
(congr h2 (congr h1 ψs)) = congr (by rw [h1, h2]) ψs := by
subst h1 h2
@ -236,7 +236,7 @@ def take (n : ℕ) (ψs : CrAnSection φs) : CrAnSection (φs.take n) :=
⟨ψs.1.take n, by simp [ψs.2]⟩
@[simp]
lemma take_congr {φs φs' : List 𝓕.States} (h : φs = φs') (n : ℕ)
lemma take_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs') (n : ℕ)
(ψs : CrAnSection φs) :
(take n (congr h ψs)) = congr (by rw [h]) (take n ψs) := by
subst h
@ -247,31 +247,31 @@ def drop (n : ℕ) (ψs : CrAnSection φs) : CrAnSection (φs.drop n) :=
⟨ψs.1.drop n, by simp [ψs.2]⟩
@[simp]
lemma drop_congr {φs φs' : List 𝓕.States} (h : φs = φs') (n : ℕ)
lemma drop_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs') (n : ℕ)
(ψs : CrAnSection φs) :
(drop n (congr h ψs)) = congr (by rw [h]) (drop n ψs) := by
subst h
rfl
/-- Appends two sections and their underlying lists. -/
def append {φs φs' : List 𝓕.States} (ψs : CrAnSection φs)
def append {φs φs' : List 𝓕.FieldOp} (ψs : CrAnSection φs)
(ψs' : CrAnSection φs') : CrAnSection (φs ++ φs') :=
⟨ψs.1 ++ ψs'.1, by simp [ψs.2, ψs'.2]⟩
lemma append_assoc {φs φs' φs'' : List 𝓕.States} (ψs : CrAnSection φs)
lemma append_assoc {φs φs' φs'' : List 𝓕.FieldOp} (ψs : CrAnSection φs)
(ψs' : CrAnSection φs') (ψs'' : CrAnSection φs'') :
append ψs (append ψs' ψs'') = congr (by simp) (append (append ψs ψs') ψs'') := by
apply Subtype.ext
simp [append]
lemma append_assoc' {φs φs' φs'' : List 𝓕.States} (ψs : CrAnSection φs)
lemma append_assoc' {φs φs' φs'' : List 𝓕.FieldOp} (ψs : CrAnSection φs)
(ψs' : CrAnSection φs') (ψs'' : CrAnSection φs'') :
(append (append ψs ψs') ψs'') = congr (by simp) (append ψs (append ψs' ψs'')) := by
apply Subtype.ext
simp [append]
lemma singletonEquiv_append_eq_cons {φs : List 𝓕.States} {φ : 𝓕.States}
(ψs : CrAnSection φs) (ψ : 𝓕.statesToCrAnType φ) :
lemma singletonEquiv_append_eq_cons {φs : List 𝓕.FieldOp} {φ : 𝓕.FieldOp}
(ψs : CrAnSection φs) (ψ : 𝓕.fieldOpToCrAnType φ) :
append (singletonEquiv.symm ψ) ψs = cons ψ ψs := by
apply Subtype.ext
simp [append, cons, singletonEquiv]
@ -282,35 +282,35 @@ lemma take_append_drop {n : ℕ} (ψs : CrAnSection φs) :
apply Subtype.ext
simp [take, drop, append]
lemma congr_append {φs1 φs1' φs2 φs2' : List 𝓕.States} (h1 : φs1 = φs1') (h2 : φs2 = φs2')
lemma congr_append {φs1 φs1' φs2 φs2' : List 𝓕.FieldOp} (h1 : φs1 = φs1') (h2 : φs2 = φs2')
(ψs1 : CrAnSection φs1) (ψs2 : CrAnSection φs2) :
(append (congr h1 ψs1) (congr h2 ψs2)) = congr (by rw [h1, h2]) (append ψs1 ψs2) := by
subst h1 h2
rfl
@[simp]
lemma congr_fst_append {φs1 φs1' φs2 : List 𝓕.States} (h1 : φs1 = φs1')
lemma congr_fst_append {φs1 φs1' φs2 : List 𝓕.FieldOp} (h1 : φs1 = φs1')
(ψs1 : CrAnSection φs1) (ψs2 : CrAnSection φs2) :
(append (congr h1 ψs1) (ψs2)) = congr (by rw [h1]) (append ψs1 ψs2) := by
subst h1
rfl
@[simp]
lemma congr_snd_append {φs1 φs2 φs2' : List 𝓕.States} (h2 : φs2 = φs2')
lemma congr_snd_append {φs1 φs2 φs2' : List 𝓕.FieldOp} (h2 : φs2 = φs2')
(ψs1 : CrAnSection φs1) (ψs2 : CrAnSection φs2) :
(append ψs1 (congr h2 ψs2)) = congr (by rw [h2]) (append ψs1 ψs2) := by
subst h2
rfl
@[simp]
lemma take_left {φs φs' : List 𝓕.States} (ψs : CrAnSection φs)
lemma take_left {φs φs' : List 𝓕.FieldOp} (ψs : CrAnSection φs)
(ψs' : CrAnSection φs') :
take φs.length (ψs.append ψs') = congr (by simp) ψs := by
apply Subtype.ext
simp [take, append]
@[simp]
lemma drop_left {φs φs' : List 𝓕.States} (ψs : CrAnSection φs)
lemma drop_left {φs φs' : List 𝓕.FieldOp} (ψs : CrAnSection φs)
(ψs' : CrAnSection φs') :
drop φs.length (ψs.append ψs') = congr (by simp) ψs' := by
apply Subtype.ext
@ -319,7 +319,7 @@ lemma drop_left {φs φs' : List 𝓕.States} (ψs : CrAnSection φs)
/-- The equivalence between `CrAnSection (φs ++ φs')` and
`CrAnSection φs × CrAnSection φs` formed by `append`, `take`
and `drop` and their interrelationship. -/
def appendEquiv {φs φs' : List 𝓕.States} : CrAnSection (φs ++ φs') ≃
def appendEquiv {φs φs' : List 𝓕.FieldOp} : CrAnSection (φs ++ φs') ≃
CrAnSection φs × CrAnSection φs' where
toFun ψs := (congr (List.take_left φs φs') (take φs.length ψs),
congr (List.drop_left φs φs') (drop φs.length ψs))
@ -349,8 +349,8 @@ def eraseIdx (n : ℕ) (ψs : CrAnSection φs) : CrAnSection (φs.eraseIdx n) :=
⟨ψs.1.eraseIdx n, by simp [ψs.2]⟩
/-- The equivalence formed by extracting an element from a section. -/
def eraseIdxEquiv (n : ℕ) (φs : List 𝓕.States) (hn : n < φs.length) :
CrAnSection φs ≃ 𝓕.statesToCrAnType φs[n] ×
def eraseIdxEquiv (n : ℕ) (φs : List 𝓕.FieldOp) (hn : n < φs.length) :
CrAnSection φs ≃ 𝓕.fieldOpToCrAnType φs[n] ×
CrAnSection (φs.eraseIdx n) :=
(congr (by simp only [List.take_concat_get', List.take_append_drop])).trans <|
appendEquiv.trans <|
@ -372,8 +372,8 @@ lemma eraseIdxEquiv_apply_snd {n : ℕ} (ψs : CrAnSection φs) (hn : n < φs.le
simp only [Nat.succ_eq_add_one, le_add_iff_nonneg_right, zero_le, inf_of_le_left]
exact Eq.symm (List.eraseIdx_eq_take_drop_succ ψs.1 n)
lemma eraseIdxEquiv_symm_eq_take_cons_drop {n : ℕ} (φs : List 𝓕.States) (hn : n < φs.length)
(a : 𝓕.statesToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
lemma eraseIdxEquiv_symm_eq_take_cons_drop {n : ℕ} (φs : List 𝓕.FieldOp) (hn : n < φs.length)
(a : 𝓕.fieldOpToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
(eraseIdxEquiv n φs hn).symm ⟨a, s⟩ =
congr (by
rw [HepLean.List.take_eraseIdx_same, HepLean.List.drop_eraseIdx_succ]
@ -394,8 +394,8 @@ lemma eraseIdxEquiv_symm_eq_take_cons_drop {n : ℕ} (φs : List 𝓕.States) (h
rw [hn]
@[simp]
lemma eraseIdxEquiv_symm_getElem {n : ℕ} (φs : List 𝓕.States) (hn : n < φs.length)
(a : 𝓕.statesToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
lemma eraseIdxEquiv_symm_getElem {n : ℕ} (φs : List 𝓕.FieldOp) (hn : n < φs.length)
(a : 𝓕.fieldOpToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
getElem ((eraseIdxEquiv n φs hn).symm ⟨a,s⟩).1 n
(by rw [length_eq]; exact hn) = ⟨φs[n], a⟩ := by
rw [eraseIdxEquiv_symm_eq_take_cons_drop]
@ -409,16 +409,16 @@ lemma eraseIdxEquiv_symm_getElem {n : ℕ} (φs : List 𝓕.States) (hn : n < φ
simp [h0]
@[simp]
lemma eraseIdxEquiv_symm_eraseIdx {n : ℕ} (φs : List 𝓕.States) (hn : n < φs.length)
(a : 𝓕.statesToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
lemma eraseIdxEquiv_symm_eraseIdx {n : ℕ} (φs : List 𝓕.FieldOp) (hn : n < φs.length)
(a : 𝓕.fieldOpToCrAnType φs[n]) (s : CrAnSection (φs.eraseIdx n)) :
((eraseIdxEquiv n φs hn).symm ⟨a, s⟩).1.eraseIdx n = s.1 := by
change (((eraseIdxEquiv n φs hn).symm ⟨a, s⟩).eraseIdx n).1 = _
rw [← eraseIdxEquiv_apply_snd _ hn]
simp
lemma sum_eraseIdxEquiv (n : ℕ) (φs : List 𝓕.States) (hn : n < φs.length)
lemma sum_eraseIdxEquiv (n : ℕ) (φs : List 𝓕.FieldOp) (hn : n < φs.length)
(f : CrAnSection φs → M) [AddCommMonoid M] : ∑ (s : CrAnSection φs), f s =
∑ (a : 𝓕.statesToCrAnType φs[n]), ∑ (s : CrAnSection (φs.eraseIdx n)),
∑ (a : 𝓕.fieldOpToCrAnType φs[n]), ∑ (s : CrAnSection (φs.eraseIdx n)),
f ((eraseIdxEquiv n φs hn).symm ⟨a, s⟩) := by
rw [← (eraseIdxEquiv n φs hn).symm.sum_comp]
rw [Fintype.sum_prod_type]

102
HepLean/PerturbationTheory/FieldSpecification/CrAnStates.lean
View file

@ -1,102 +0,0 @@
/-
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.FieldSpecification.Basic
import HepLean.PerturbationTheory.CreateAnnihilate
/-!
# Creation and annihilation states
Called `CrAnStates` for short here.
Given a field specification, in addition to defining states
(see: `HepLean.PerturbationTheory.FieldSpecification.Basic`),
we can also define creation and annihilation states.
These are similar to states but come with an additional specification of whether they correspond to
creation or annihilation operators.
In particular we have the following creation and annihilation states for each field:
- Negative asymptotic states - with the implicit specification that it is a creation state.
- Position states with a creation specification.
- Position states with an annihilation specification.
- Positive asymptotic states - with the implicit specification that it is an annihilation state.
In this module in addition to defining `CrAnStates` we also define some maps:
- The map `crAnStatesToStates` takes a `CrAnStates` to its state in `States`.
- The map `crAnStatesToCreateAnnihilate` takes a `CrAnStates` to its corresponding
`CreateAnnihilate` value.
- The map `crAnStatistics` takes a `CrAnStates` to its corresponding `FieldStatistic`
(bosonic or fermionic).
-/
namespace FieldSpecification
variable (𝓕 : FieldSpecification)
/-- To each state the specificaition of the type of creation and annihlation parts.
For asymptotic staes there is only one allowed part, whilst for position states
there is two. -/
def statesToCrAnType : 𝓕.States → Type
| States.inAsymp _ => Unit
| States.position _ => CreateAnnihilate
| States.outAsymp _ => Unit
/-- The instance of a finite type on `𝓕.statesToCreateAnnihilateType i`. -/
instance : ∀ i, Fintype (𝓕.statesToCrAnType i) := fun i =>
match i with
| States.inAsymp _ => inferInstanceAs (Fintype Unit)
| States.position _ => inferInstanceAs (Fintype CreateAnnihilate)
| States.outAsymp _ => inferInstanceAs (Fintype Unit)
/-- The instance of a decidable equality on `𝓕.statesToCreateAnnihilateType i`. -/
instance : ∀ i, DecidableEq (𝓕.statesToCrAnType i) := fun i =>
match i with
| States.inAsymp _ => inferInstanceAs (DecidableEq Unit)
| States.position _ => inferInstanceAs (DecidableEq CreateAnnihilate)
| States.outAsymp _ => inferInstanceAs (DecidableEq Unit)
/-- The equivalence between `𝓕.statesToCreateAnnihilateType i` and
`𝓕.statesToCreateAnnihilateType j` from an equality `i = j`. -/
def statesToCreateAnnihilateTypeCongr : {i j : 𝓕.States} → i = j →
𝓕.statesToCrAnType i ≃ 𝓕.statesToCrAnType j
| _, _, rfl => Equiv.refl _
/-- A creation and annihlation state is a state plus an valid specification of the
creation or annihliation part of that state. (For asympotic states there is only one valid
choice). -/
def CrAnStates : Type := Σ (s : 𝓕.States), 𝓕.statesToCrAnType s
/-- The map from creation and annihlation states to their underlying states. -/
def crAnStatesToStates : 𝓕.CrAnStates → 𝓕.States := Sigma.fst
@[simp]
lemma crAnStatesToStates_prod (s : 𝓕.States) (t : 𝓕.statesToCrAnType s) :
𝓕.crAnStatesToStates ⟨s, t⟩ = s := rfl
/-- The map from creation and annihlation states to the type `CreateAnnihilate`
specifying if a state is a creation or an annihilation state. -/
def crAnStatesToCreateAnnihilate : 𝓕.CrAnStates → CreateAnnihilate
| ⟨States.inAsymp _, _⟩ => CreateAnnihilate.create
| ⟨States.position _, CreateAnnihilate.create⟩ => CreateAnnihilate.create
| ⟨States.position _, CreateAnnihilate.annihilate⟩ => CreateAnnihilate.annihilate
| ⟨States.outAsymp _, _⟩ => CreateAnnihilate.annihilate
/-- Takes a `CrAnStates` state to its corresponding fields statistic (bosonic or fermionic). -/
def crAnStatistics : 𝓕.CrAnStates → FieldStatistic :=
𝓕.statesStatistic ∘ 𝓕.crAnStatesToStates
/-- The field statistic of a `CrAnState`. -/
scoped[FieldSpecification] notation 𝓕 "|>ₛ" φ =>
(crAnStatistics 𝓕) φ
/-- The field statistic of a list of `CrAnState`s. -/
scoped[FieldSpecification] notation 𝓕 "|>ₛ" φ => FieldStatistic.ofList
(crAnStatistics 𝓕) φ
/-- The `CreateAnnihilate` value of a `CrAnState`s, i.e. whether it is a creation or
annihilation operator. -/
scoped[FieldSpecification] infixl:80 "|>ᶜ" =>
crAnStatesToCreateAnnihilate
end FieldSpecification

36
HepLean/PerturbationTheory/FieldSpecification/Filters.lean
View file

@ -3,10 +3,10 @@ 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.FieldSpecification.CrAnStates
import HepLean.PerturbationTheory.FieldSpecification.CrAnFieldOp
/-!
# Filters of lists of CrAnStates
# Filters of lists of CrAnFieldOp
-/
@ -17,34 +17,34 @@ variable {𝓕 : FieldSpecification}
the creation states. As a schematic example, for the list:
- `[φ1c, φ1a, φ2c, φ2a]` this will return `[φ1c, φ2c]`.
-/
def createFilter (φs : List 𝓕.CrAnStates) : List 𝓕.CrAnStates :=
def createFilter (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp :=
List.filter (fun φ => 𝓕 |>ᶜ φ = CreateAnnihilate.create) φs
lemma createFilter_cons_create {φ : 𝓕.CrAnStates}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
lemma createFilter_cons_create {φ : 𝓕.CrAnFieldOp}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnFieldOp) :
createFilter (φ :: φs) = φ :: createFilter φs := by
simp only [createFilter]
rw [List.filter_cons_of_pos]
simp [hφ]
lemma createFilter_cons_annihilate {φ : 𝓕.CrAnStates}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
lemma createFilter_cons_annihilate {φ : 𝓕.CrAnFieldOp}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnFieldOp) :
createFilter (φ :: φs) = createFilter φs := by
simp only [createFilter]
rw [List.filter_cons_of_neg]
simp [hφ]
lemma createFilter_append (φs φs' : List 𝓕.CrAnStates) :
lemma createFilter_append (φs φs' : List 𝓕.CrAnFieldOp) :
createFilter (φs ++ φs') = createFilter φs ++ createFilter φs' := by
rw [createFilter, List.filter_append]
rfl
lemma createFilter_singleton_create (φ : 𝓕.CrAnStates)
lemma createFilter_singleton_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) :
createFilter [φ] = [φ] := by
simp [createFilter, hφ]
lemma createFilter_singleton_annihilate (φ : 𝓕.CrAnStates)
lemma createFilter_singleton_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) : createFilter [φ] = [] := by
simp [createFilter, hφ]
@ -53,34 +53,34 @@ lemma createFilter_singleton_annihilate (φ : 𝓕.CrAnStates)
As a schematic example, for the list:
- `[φ1c, φ1a, φ2c, φ2a]` this will return `[φ1a, φ2a]`.
-/
def annihilateFilter (φs : List 𝓕.CrAnStates) : List 𝓕.CrAnStates :=
def annihilateFilter (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp :=
List.filter (fun φ => 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) φs
lemma annihilateFilter_cons_create {φ : 𝓕.CrAnStates}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
lemma annihilateFilter_cons_create {φ : 𝓕.CrAnFieldOp}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnFieldOp) :
annihilateFilter (φ :: φs) = annihilateFilter φs := by
simp only [annihilateFilter]
rw [List.filter_cons_of_neg]
simp [hφ]
lemma annihilateFilter_cons_annihilate {φ : 𝓕.CrAnStates}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
lemma annihilateFilter_cons_annihilate {φ : 𝓕.CrAnFieldOp}
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnFieldOp) :
annihilateFilter (φ :: φs) = φ :: annihilateFilter φs := by
simp only [annihilateFilter]
rw [List.filter_cons_of_pos]
simp [hφ]
lemma annihilateFilter_append (φs φs' : List 𝓕.CrAnStates) :
lemma annihilateFilter_append (φs φs' : List 𝓕.CrAnFieldOp) :
annihilateFilter (φs ++ φs') = annihilateFilter φs ++ annihilateFilter φs' := by
rw [annihilateFilter, List.filter_append]
rfl
lemma annihilateFilter_singleton_create (φ : 𝓕.CrAnStates)
lemma annihilateFilter_singleton_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) :
annihilateFilter [φ] = [] := by
simp [annihilateFilter, hφ]
lemma annihilateFilter_singleton_annihilate (φ : 𝓕.CrAnStates)
lemma annihilateFilter_singleton_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
annihilateFilter [φ] = [φ] := by
simp [annihilateFilter, hφ]

110
HepLean/PerturbationTheory/FieldSpecification/NormalOrder.lean
View file

@ -21,19 +21,19 @@ variable {𝓕 : FieldSpecification}
- `φ1` is a creation operator
or
- `φ2` is an annihlate operator. -/
def normalOrderRel : 𝓕.CrAnStates → 𝓕.CrAnStates → Prop :=
def normalOrderRel : 𝓕.CrAnFieldOp → 𝓕.CrAnFieldOp → Prop :=
fun a b => CreateAnnihilate.normalOrder (𝓕 |>ᶜ a) (𝓕 |>ᶜ b)
/-- Normal ordering is total. -/
instance : IsTotal 𝓕.CrAnStates 𝓕.normalOrderRel where
instance : IsTotal 𝓕.CrAnFieldOp 𝓕.normalOrderRel where
total _ _ := total_of CreateAnnihilate.normalOrder _ _
/-- Normal ordering is transitive. -/
instance : IsTrans 𝓕.CrAnStates 𝓕.normalOrderRel where
instance : IsTrans 𝓕.CrAnFieldOp 𝓕.normalOrderRel where
trans _ _ _ := fun h h' => IsTrans.trans (α := CreateAnnihilate) _ _ _ h h'
/-- A decidable instance on the normal ordering relation. -/
instance (φ φ' : 𝓕.CrAnStates) : Decidable (normalOrderRel φ φ') :=
instance (φ φ' : 𝓕.CrAnFieldOp) : Decidable (normalOrderRel φ φ') :=
CreateAnnihilate.instDecidableNormalOrder (𝓕 |>ᶜ φ) (𝓕 |>ᶜ φ')
/-!
@ -45,16 +45,16 @@ instance (φ φ' : 𝓕.CrAnStates) : Decidable (normalOrderRel φ φ') :=
/-- The sign associated with putting a list of creation and annihlation states into normal order
(with the creation operators on the left).
We pick up a minus sign for every fermion paired crossed. -/
def normalOrderSign (φs : List 𝓕.CrAnStates) : ℂ :=
def normalOrderSign (φs : List 𝓕.CrAnFieldOp) : ℂ :=
Wick.koszulSign 𝓕.crAnStatistics 𝓕.normalOrderRel φs
@[simp]
lemma normalOrderSign_mul_self (φs : List 𝓕.CrAnStates) :
lemma normalOrderSign_mul_self (φs : List 𝓕.CrAnFieldOp) :
normalOrderSign φs * normalOrderSign φs = 1 := by
simp [normalOrderSign, Wick.koszulSign, Wick.koszulSign_mul_self]
lemma koszulSignInsert_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) : (φs : List 𝓕.CrAnStates) →
lemma koszulSignInsert_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) : (φs : List 𝓕.CrAnFieldOp) →
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ φs = 1
| [] => rfl
| φ' :: φs => by
@ -65,21 +65,21 @@ lemma koszulSignInsert_create (φ : 𝓕.CrAnStates)
rw [hφ]
dsimp [CreateAnnihilate.normalOrder]
lemma normalOrderSign_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
lemma normalOrderSign_cons_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnFieldOp) :
normalOrderSign (φ :: φs) = normalOrderSign φs := by
simp [normalOrderSign, Wick.koszulSign, koszulSignInsert_create φ hφ φs]
@[simp]
lemma normalOrderSign_singleton (φ : 𝓕.CrAnStates) : normalOrderSign [φ] = 1 := by
lemma normalOrderSign_singleton (φ : 𝓕.CrAnFieldOp) : normalOrderSign [φ] = 1 := by
simp [normalOrderSign]
@[simp]
lemma normalOrderSign_nil : normalOrderSign (𝓕 := 𝓕) [] = 1 := rfl
lemma koszulSignInsert_append_annihilate (φ' φ : 𝓕.CrAnStates)
lemma koszulSignInsert_append_annihilate (φ' φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
(φs : List 𝓕.CrAnStates) →
(φs : List 𝓕.CrAnFieldOp) →
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ' (φs ++ [φ]) =
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ' φs
| [] => by
@ -90,9 +90,9 @@ lemma koszulSignInsert_append_annihilate (φ' φ : 𝓕.CrAnStates)
dsimp only [List.cons_append, Wick.koszulSignInsert]
rw [koszulSignInsert_append_annihilate φ' φ hφ φs]
lemma normalOrderSign_append_annihlate (φ : 𝓕.CrAnStates)
lemma normalOrderSign_append_annihlate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
(φs : List 𝓕.CrAnStates) →
(φs : List 𝓕.CrAnFieldOp) →
normalOrderSign (φs ++ [φ]) = normalOrderSign φs
| [] => by simp
| φ' :: φs => by
@ -101,10 +101,10 @@ lemma normalOrderSign_append_annihlate (φ : 𝓕.CrAnStates)
dsimp only [normalOrderSign] at hi
rw [hi, koszulSignInsert_append_annihilate φ' φ hφ φs]
lemma koszulSignInsert_annihilate_cons_create (φc φa : 𝓕.CrAnStates)
lemma koszulSignInsert_annihilate_cons_create (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) :
(φs : List 𝓕.CrAnFieldOp) :
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φa (φc :: φs)
= FieldStatistic.exchangeSign (𝓕.crAnStatistics φc) (𝓕.crAnStatistics φa) *
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φa φs := by
@ -116,10 +116,10 @@ lemma koszulSignInsert_annihilate_cons_create (φc φa : 𝓕.CrAnStates)
rw [normalOrderRel, hφa, hφc]
simp [CreateAnnihilate.normalOrder]
lemma normalOrderSign_swap_create_annihlate_fst (φc φa : 𝓕.CrAnStates)
lemma normalOrderSign_swap_create_annihlate_fst (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) :
(φs : List 𝓕.CrAnFieldOp) :
normalOrderSign (φc :: φa :: φs) =
FieldStatistic.exchangeSign (𝓕.crAnStatistics φc) (𝓕.crAnStatistics φa) *
normalOrderSign (φa :: φc :: φs) := by
@ -131,14 +131,14 @@ lemma normalOrderSign_swap_create_annihlate_fst (φc φa : 𝓕.CrAnStates)
rw [one_mul, normalOrderSign_cons_create φc hφc φs]
rfl
lemma koszulSignInsert_swap (φ φc φa : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
lemma koszulSignInsert_swap (φ φc φa : 𝓕.CrAnFieldOp) (φs φs' : List 𝓕.CrAnFieldOp) :
Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ (φs ++ φa :: φc :: φs')
= Wick.koszulSignInsert 𝓕.crAnStatistics normalOrderRel φ (φs ++ φc :: φa :: φs') :=
Wick.koszulSignInsert_eq_perm _ _ _ _ _ (List.Perm.append_left φs (List.Perm.swap φc φa φs'))
lemma normalOrderSign_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
lemma normalOrderSign_swap_create_annihlate (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate) :
(φs φs' : List 𝓕.CrAnStates) → normalOrderSign (φs ++ φc :: φa :: φs') =
(φs φs' : List 𝓕.CrAnFieldOp) → normalOrderSign (φs ++ φc :: φa :: φs') =
FieldStatistic.exchangeSign (𝓕.crAnStatistics φc) (𝓕.crAnStatistics φa) *
normalOrderSign (φs ++ φa :: φc :: φs')
| [], φs' => normalOrderSign_swap_create_annihlate_fst φc φa hφc hφa φs'
@ -154,16 +154,16 @@ lemma normalOrderSign_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
left
rw [koszulSignInsert_swap]
lemma normalOrderSign_swap_create_create_fst (φc φc' : 𝓕.CrAnStates)
lemma normalOrderSign_swap_create_create_fst (φc φc' : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create)
(φs : List 𝓕.CrAnStates) :
(φs : List 𝓕.CrAnFieldOp) :
normalOrderSign (φc :: φc' :: φs) = normalOrderSign (φc' :: φc :: φs) := by
rw [normalOrderSign_cons_create φc hφc, normalOrderSign_cons_create φc' hφc']
rw [normalOrderSign_cons_create φc' hφc', normalOrderSign_cons_create φc hφc]
lemma normalOrderSign_swap_create_create (φc φc' : 𝓕.CrAnStates)
lemma normalOrderSign_swap_create_create (φc φc' : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create) :
(φs φs' : List 𝓕.CrAnStates) →
(φs φs' : List 𝓕.CrAnFieldOp) →
normalOrderSign (φs ++ φc :: φc' :: φs') = normalOrderSign (φs ++ φc' :: φc :: φs')
| [], φs' => by
exact normalOrderSign_swap_create_create_fst φc φc' hφc hφc' φs'
@ -177,10 +177,10 @@ lemma normalOrderSign_swap_create_create (φc φc' : 𝓕.CrAnStates)
apply Or.inl (Wick.koszulSignInsert_eq_perm _ _ _ _ _ _)
exact List.Perm.append_left φs (List.Perm.swap φc' φc φs')
lemma normalOrderSign_swap_annihilate_annihilate_fst (φa φa' : 𝓕.CrAnStates)
lemma normalOrderSign_swap_annihilate_annihilate_fst (φa φa' : 𝓕.CrAnFieldOp)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) :
(φs : List 𝓕.CrAnFieldOp) :
normalOrderSign (φa :: φa' :: φs) =
normalOrderSign (φa' :: φa :: φs) := by
rw [normalOrderSign, normalOrderSign]
@ -195,9 +195,9 @@ lemma normalOrderSign_swap_annihilate_annihilate_fst (φa φa' : 𝓕.CrAnStates
· simp [normalOrderRel, hφa, hφa', CreateAnnihilate.normalOrder]
· rw [NonUnitalNormedCommRing.mul_comm]
lemma normalOrderSign_swap_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
lemma normalOrderSign_swap_annihilate_annihilate (φa φa' : 𝓕.CrAnFieldOp)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate) : (φs φs' : List 𝓕.CrAnStates) →
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate) : (φs φs' : List 𝓕.CrAnFieldOp) →
normalOrderSign (φs ++ φa :: φa' :: φs') = normalOrderSign (φs ++ φa' :: φa :: φs')
| [], φs' => by
exact normalOrderSign_swap_annihilate_annihilate_fst φa φa' hφa hφa' φs'
@ -225,7 +225,7 @@ open FieldStatistic
To give some schematic. For example:
- `normalOrderList [φ1c, φ1a, φ2c, φ2a] = [φ1c, φ2c, φ1a, φ2a]`
-/
def normalOrderList (φs : List 𝓕.CrAnStates) : List 𝓕.CrAnStates :=
def normalOrderList (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp :=
List.insertionSort 𝓕.normalOrderRel φs
@[simp]
@ -233,13 +233,13 @@ lemma normalOrderList_nil : normalOrderList (𝓕 := 𝓕) [] = [] := by
simp [normalOrderList]
@[simp]
lemma normalOrderList_statistics (φs : List 𝓕.CrAnStates) :
lemma normalOrderList_statistics (φs : List 𝓕.CrAnFieldOp) :
(𝓕 |>ₛ (normalOrderList φs)) = 𝓕 |>ₛ φs := by
simp [normalOrderList, List.insertionSort]
lemma orderedInsert_create (φ : 𝓕.CrAnStates)
lemma orderedInsert_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) :
(φs : List 𝓕.CrAnStates) → List.orderedInsert normalOrderRel φ φs = φ :: φs
(φs : List 𝓕.CrAnFieldOp) → List.orderedInsert normalOrderRel φ φs = φ :: φs
| [] => rfl
| φ' :: φs => by
dsimp only [List.orderedInsert.eq_2]
@ -248,15 +248,15 @@ lemma orderedInsert_create (φ : 𝓕.CrAnStates)
rw [hφ]
dsimp [CreateAnnihilate.normalOrder]
lemma normalOrderList_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
lemma normalOrderList_cons_create (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnFieldOp) :
normalOrderList (φ :: φs) = φ :: normalOrderList φs := by
simp only [normalOrderList, List.insertionSort]
rw [orderedInsert_create φ hφ]
lemma orderedInsert_append_annihilate (φ' φ : 𝓕.CrAnStates)
lemma orderedInsert_append_annihilate (φ' φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
(φs : List 𝓕.CrAnStates) → List.orderedInsert normalOrderRel φ' (φs ++ [φ]) =
(φs : List 𝓕.CrAnFieldOp) → List.orderedInsert normalOrderRel φ' (φs ++ [φ]) =
List.orderedInsert normalOrderRel φ' φs ++ [φ]
| [] => by
simp [Wick.koszulSignInsert, normalOrderRel, hφ]
@ -268,9 +268,9 @@ lemma orderedInsert_append_annihilate (φ' φ : 𝓕.CrAnStates)
next h => simp_all only [List.cons_append]
next h => simp_all only [List.cons_append]
lemma normalOrderList_append_annihilate (φ : 𝓕.CrAnStates)
lemma normalOrderList_append_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) :
(φs : List 𝓕.CrAnStates) →
(φs : List 𝓕.CrAnFieldOp) →
normalOrderList (φs ++ [φ]) = normalOrderList φs ++ [φ]
| [] => by simp [normalOrderList]
| φ' :: φs => by
@ -279,10 +279,10 @@ lemma normalOrderList_append_annihilate (φ : 𝓕.CrAnStates)
dsimp only [normalOrderList] at hi
rw [hi, orderedInsert_append_annihilate φ' φ hφ]
lemma normalOrder_swap_create_annihlate_fst (φc φa : 𝓕.CrAnStates)
lemma normalOrder_swap_create_annihlate_fst (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) :
(φs : List 𝓕.CrAnFieldOp) :
normalOrderList (φc :: φa :: φs) = normalOrderList (φa :: φc :: φs) := by
rw [normalOrderList_cons_create φc hφc (φa :: φs)]
conv_rhs =>
@ -297,10 +297,10 @@ lemma normalOrder_swap_create_annihlate_fst (φc φa : 𝓕.CrAnStates)
dsimp [CreateAnnihilate.normalOrder] at h
· rfl
lemma normalOrderList_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
lemma normalOrderList_swap_create_annihlate (φc φa : 𝓕.CrAnFieldOp)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate) :
(φs φs' : List 𝓕.CrAnStates) →
(φs φs' : List 𝓕.CrAnFieldOp) →
normalOrderList (φs ++ φc :: φa :: φs') = normalOrderList (φs ++ φa :: φc :: φs')
| [], φs' => normalOrder_swap_create_annihlate_fst φc φa hφc hφa φs'
| φ :: φs, φs' => by
@ -316,16 +316,16 @@ lemma normalOrderList_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
For example:
- For `[φ1c, φ1a, φ2c, φ2a]` this equivalence sends `0 ↦ 0`, `1 ↦ 2`, `2 ↦ 1`, `3 ↦ 3`.
-/
def normalOrderEquiv {φs : List 𝓕.CrAnStates} : Fin φs.length ≃ Fin (normalOrderList φs).length :=
def normalOrderEquiv {φs : List 𝓕.CrAnFieldOp} : Fin φs.length ≃ Fin (normalOrderList φs).length :=
HepLean.List.insertionSortEquiv 𝓕.normalOrderRel φs
lemma sum_normalOrderList_length {M : Type} [AddCommMonoid M]
(φs : List 𝓕.CrAnStates) (f : Fin (normalOrderList φs).length → M) :
(φs : List 𝓕.CrAnFieldOp) (f : Fin (normalOrderList φs).length → M) :
∑ (n : Fin (normalOrderList φs).length), f n = ∑ (n : Fin φs.length), f (normalOrderEquiv n) :=
Eq.symm (Equiv.sum_comp normalOrderEquiv f)
@[simp]
lemma normalOrderList_get_normalOrderEquiv {φs : List 𝓕.CrAnStates} (n : Fin φs.length) :
lemma normalOrderList_get_normalOrderEquiv {φs : List 𝓕.CrAnFieldOp} (n : Fin φs.length) :
(normalOrderList φs)[(normalOrderEquiv n).val] = φs[n.val] := by
change (normalOrderList φs).get (normalOrderEquiv n) = _
simp only [normalOrderList, normalOrderEquiv]
@ -333,21 +333,21 @@ lemma normalOrderList_get_normalOrderEquiv {φs : List 𝓕.CrAnStates} (n : Fin
simp
@[simp]
lemma normalOrderList_eraseIdx_normalOrderEquiv {φs : List 𝓕.CrAnStates} (n : Fin φs.length) :
lemma normalOrderList_eraseIdx_normalOrderEquiv {φs : List 𝓕.CrAnFieldOp} (n : Fin φs.length) :
(normalOrderList φs).eraseIdx (normalOrderEquiv n).val =
normalOrderList (φs.eraseIdx n.val) := by
simp only [normalOrderList, normalOrderEquiv]
rw [HepLean.List.eraseIdx_insertionSort_fin]
lemma normalOrderSign_eraseIdx (φs : List 𝓕.CrAnStates) (n : Fin φs.length) :
lemma normalOrderSign_eraseIdx (φs : List 𝓕.CrAnFieldOp) (n : Fin φs.length) :
normalOrderSign (φs.eraseIdx n) = normalOrderSign φs *
𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ (φs.take n)) *
𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv n))) := by
rw [normalOrderSign, Wick.koszulSign_eraseIdx, ← normalOrderSign]
rfl
lemma orderedInsert_createFilter_append_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) : (φs φs' : List 𝓕.CrAnStates) →
lemma orderedInsert_createFilter_append_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) : (φs φs' : List 𝓕.CrAnFieldOp) →
List.orderedInsert normalOrderRel φ (createFilter φs ++ φs') =
createFilter φs ++ List.orderedInsert normalOrderRel φ φs'
| [], φs' => by simp [createFilter]
@ -359,7 +359,7 @@ lemma orderedInsert_createFilter_append_annihilate (φ : 𝓕.CrAnStates)
simp [normalOrderRel, hφ, hφ', CreateAnnihilate.normalOrder]
· rw [createFilter_cons_annihilate hφ', orderedInsert_createFilter_append_annihilate φ hφ φs]
lemma orderedInsert_annihilateFilter (φ : 𝓕.CrAnStates) : (φs : List 𝓕.CrAnStates) →
lemma orderedInsert_annihilateFilter (φ : 𝓕.CrAnFieldOp) : (φs : List 𝓕.CrAnFieldOp) →
List.orderedInsert normalOrderRel φ (annihilateFilter φs) =
φ :: annihilateFilter φs
| [] => by simp [annihilateFilter]
@ -377,13 +377,13 @@ lemma orderedInsert_annihilateFilter (φ : 𝓕.CrAnStates) : (φs : List 𝓕.C
· rw [hφ]
simp [CreateAnnihilate.normalOrder]
lemma orderedInsert_createFilter_append_annihilateFilter_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
lemma orderedInsert_createFilter_append_annihilateFilter_annihilate (φ : 𝓕.CrAnFieldOp)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnFieldOp) :
List.orderedInsert normalOrderRel φ (createFilter φs ++ annihilateFilter φs) =
createFilter φs ++ φ :: annihilateFilter φs := by
rw [orderedInsert_createFilter_append_annihilate φ hφ, orderedInsert_annihilateFilter]
lemma normalOrderList_eq_createFilter_append_annihilateFilter : (φs : List 𝓕.CrAnStates) →
lemma normalOrderList_eq_createFilter_append_annihilateFilter : (φs : List 𝓕.CrAnFieldOp) →
normalOrderList φs = createFilter φs ++ annihilateFilter φs
| [] => by simp [normalOrderList, createFilter, annihilateFilter]
| φ :: φs => by

192
HepLean/PerturbationTheory/FieldSpecification/TimeOrder.lean
View file

@ -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

4
HepLean/PerturbationTheory/WickContraction/Basic.lean
View file

@ -523,10 +523,10 @@ lemma prod_finset_eq_mul_fst_snd (c : WickContraction n) (a : c.1)
/-- A Wick contraction associated with a list of states is said to be `GradingCompliant` if in any
contracted pair of states they are either both fermionic or both bosonic. -/
def GradingCompliant (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) :=
def GradingCompliant (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) :=
∀ (a : φsΛ.1), (𝓕 |>ₛ φs[φsΛ.fstFieldOfContract a]) = (𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a])
lemma gradingCompliant_congr {φs φs' : List 𝓕.States} (h : φs = φs')
lemma gradingCompliant_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs')
(φsΛ : WickContraction φs.length) :
GradingCompliant φs φsΛ ↔ GradingCompliant φs' (congr (by simp [h]) φsΛ) := by
subst h

48
HepLean/PerturbationTheory/WickContraction/InsertAndContract.lean
View file

@ -29,7 +29,7 @@ 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 insertAndContract {φs : List 𝓕.States} (φ : 𝓕.States) (φsΛ : WickContraction φs.length)
def insertAndContract {φs : List 𝓕.FieldOp} (φ : 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : Option φsΛ.uncontracted) :
WickContraction (φs.insertIdx i φ).length :=
congr (by simp) (φsΛ.insertAndContractNat i j)
@ -38,7 +38,7 @@ def insertAndContract {φs : List 𝓕.States} (φ : 𝓕.States) (φsΛ : WickC
scoped[WickContraction] notation φs "↩Λ" φ:max i:max j => insertAndContract φ φs i j
@[simp]
lemma insertAndContract_fstFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_fstFieldOfContract (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option φsΛ.uncontracted)
(a : φsΛ.1) : (φsΛ ↩Λ φ i j).fstFieldOfContract
(congrLift (insertIdx_length_fin φ φs i).symm (insertLift i j a)) =
@ -46,7 +46,7 @@ lemma insertAndContract_fstFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.S
simp [insertAndContract]
@[simp]
lemma insertAndContract_sndFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_sndFieldOfContract (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Option (φsΛ.uncontracted))
(a : φsΛ.1) : (φsΛ ↩Λ φ i j).sndFieldOfContract
(congrLift (insertIdx_length_fin φ φs i).symm (insertLift i j a)) =
@ -54,7 +54,7 @@ lemma insertAndContract_sndFieldOfContract (φ : 𝓕.States) (φs : List 𝓕.S
simp [insertAndContract]
@[simp]
lemma insertAndContract_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_fstFieldOfContract_some_incl (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(insertAndContract φ φsΛ i (some j)).fstFieldOfContract
(congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by
@ -92,7 +92,7 @@ lemma insertAndContract_fstFieldOfContract_some_incl (φ : 𝓕.States) (φs : L
-/
@[simp]
lemma insertAndContract_none_getDual?_self (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_none_getDual?_self (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
(φsΛ ↩Λ φ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm i) = none := by
simp only [Nat.succ_eq_add_one, insertAndContract, getDual?_congr, finCongr_apply, Fin.cast_trans,
@ -100,27 +100,27 @@ lemma insertAndContract_none_getDual?_self (φ : 𝓕.States) (φs : List 𝓕.S
have h1 := φsΛ.insertAndContractNat_none_getDual?_isNone i
simpa using h1
lemma insertAndContract_isSome_getDual?_self (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_isSome_getDual?_self (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
((φsΛ ↩Λ φ i (some j)).getDual?
(Fin.cast (insertIdx_length_fin φ φs i).symm i)).isSome := by
simp [insertAndContract, getDual?_congr]
lemma insertAndContract_some_getDual?_self_not_none (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_some_getDual?_self_not_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
¬ ((φsΛ ↩Λ φ i (some j)).getDual?
(Fin.cast (insertIdx_length_fin φ φs i).symm i)) = none := by
simp [insertAndContract, getDual?_congr]
@[simp]
lemma insertAndContract_some_getDual?_self_eq (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_some_getDual?_self_eq (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
((φ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 [insertAndContract, getDual?_congr]
@[simp]
lemma insertAndContract_some_getDual?_some_eq (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_some_getDual?_some_eq (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
((φsΛ ↩Λ φ i (some j)).getDual?
(Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove j)))
@ -131,14 +131,14 @@ lemma insertAndContract_some_getDual?_some_eq (φ : 𝓕.States) (φs : List
simp
@[simp]
lemma insertAndContract_none_succAbove_getDual?_eq_none_iff (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_none_succAbove_getDual?_eq_none_iff (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
(φsΛ ↩Λ φ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
(i.succAbove j)) = none ↔ φsΛ.getDual? j = none := by
simp [insertAndContract, getDual?_congr]
@[simp]
lemma insertAndContract_some_succAbove_getDual?_eq_option (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_some_succAbove_getDual?_eq_option (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
(k : φsΛ.uncontracted) (hkj : j ≠ k.1) :
(φsΛ ↩Λ φ i (some k)).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
@ -150,7 +150,7 @@ lemma insertAndContract_some_succAbove_getDual?_eq_option (φ : 𝓕.States) (φ
rfl
@[simp]
lemma insertAndContract_none_succAbove_getDual?_isSome_iff (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_none_succAbove_getDual?_isSome_iff (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length) :
((φsΛ ↩Λ φ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
(i.succAbove j))).isSome ↔ (φsΛ.getDual? j).isSome := by
@ -158,7 +158,7 @@ lemma insertAndContract_none_succAbove_getDual?_isSome_iff (φ : 𝓕.States) (
simp
@[simp]
lemma insertAndContract_none_getDual?_get_eq (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_none_getDual?_get_eq (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : Fin φs.length)
(h : ((φsΛ ↩Λ φ i none).getDual? (Fin.cast (insertIdx_length_fin φ φs i).symm
(i.succAbove j))).isSome) :
@ -169,7 +169,7 @@ lemma insertAndContract_none_getDual?_get_eq (φ : 𝓕.States) (φs : List 𝓕
/-........................................... -/
@[simp]
lemma insertAndContract_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_sndFieldOfContract_some_incl (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).sndFieldOfContract
(congrLift (insertIdx_length_fin φ φs i).symm ⟨{i, i.succAbove j}, by
@ -201,7 +201,7 @@ lemma insertAndContract_sndFieldOfContract_some_incl (φ : 𝓕.States) (φs : L
have hi : i.succAbove j ≠ i := Fin.succAbove_ne i j
omega
lemma insertAndContract_none_prod_contractions (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_none_prod_contractions (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ)
(f : (φsΛ ↩Λ φ i none).1 → M) [CommMonoid M] :
∏ a, f a = ∏ (a : φsΛ.1), f (congrLift (insertIdx_length_fin φ φs i).symm
@ -213,7 +213,7 @@ lemma insertAndContract_none_prod_contractions (φ : 𝓕.States) (φs : List
erw [← e1.prod_comp]
rfl
lemma insertAndContract_some_prod_contractions (φ : 𝓕.States) (φs : List 𝓕.States)
lemma insertAndContract_some_prod_contractions (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted)
(f : (φsΛ ↩Λ φ i (some j)).1 → M) [CommMonoid M] :
∏ a, f a = f (congrLift (insertIdx_length_fin φ φs i).symm
@ -231,13 +231,13 @@ lemma insertAndContract_some_prod_contractions (φ : 𝓕.States) (φs : List
/-- Given a finite set of `Fin φs.length` the finite set of `(φs.insertIdx i φ).length`
formed by mapping elements using `i.succAboveEmb` and `finCongr`. -/
def insertAndContractLiftFinset (φ : 𝓕.States) {φs : List 𝓕.States}
def insertAndContractLiftFinset (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(i : Fin φs.length.succ) (a : Finset (Fin φs.length)) :
Finset (Fin (φs.insertIdx i φ).length) :=
(a.map i.succAboveEmb).map (finCongr (insertIdx_length_fin φ φs i).symm).toEmbedding
@[simp]
lemma self_not_mem_insertAndContractLiftFinset (φ : 𝓕.States) {φs : List 𝓕.States}
lemma self_not_mem_insertAndContractLiftFinset (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(i : Fin φs.length.succ) (a : Finset (Fin φs.length)) :
Fin.cast (insertIdx_length_fin φ φs i).symm i ∉ insertAndContractLiftFinset φ i a := by
simp only [Nat.succ_eq_add_one, insertAndContractLiftFinset, Finset.mem_map_equiv, finCongr_symm,
@ -246,7 +246,7 @@ lemma self_not_mem_insertAndContractLiftFinset (φ : 𝓕.States) {φs : List
intro x
exact fun a => Fin.succAbove_ne i x
lemma succAbove_mem_insertAndContractLiftFinset (φ : 𝓕.States) {φs : List 𝓕.States}
lemma succAbove_mem_insertAndContractLiftFinset (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(i : Fin φs.length.succ) (a : Finset (Fin φs.length)) (j : Fin φs.length) :
Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove j)
∈ insertAndContractLiftFinset φ i a ↔ j ∈ a := by
@ -261,7 +261,7 @@ lemma succAbove_mem_insertAndContractLiftFinset (φ : 𝓕.States) {φs : List
· intro h
use j
lemma insert_fin_eq_self (φ : 𝓕.States) {φs : List 𝓕.States}
lemma insert_fin_eq_self (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(i : Fin φs.length.succ) (j : Fin (List.insertIdx i φ φs).length) :
j = Fin.cast (insertIdx_length_fin φ φs i).symm i
∨ ∃ k, j = Fin.cast (insertIdx_length_fin φ φs i).symm (i.succAbove k) := by
@ -276,7 +276,7 @@ lemma insert_fin_eq_self (φ : 𝓕.States) {φs : List 𝓕.States}
use z
rfl
lemma insertLift_sum (φ : 𝓕.States) {φs : List 𝓕.States}
lemma insertLift_sum (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(i : Fin φs.length.succ) [AddCommMonoid M] (f : WickContraction (φs.insertIdx i φ).length → M) :
∑ c, f c =
∑ (φsΛ : WickContraction φs.length), ∑ (k : Option φsΛ.uncontracted), f (φsΛ ↩Λ φ i k) := by
@ -289,7 +289,7 @@ lemma insertLift_sum (φ : 𝓕.States) {φs : List 𝓕.States}
## Uncontracted list
-/
lemma insertAndContract_uncontractedList_none_map (φ : 𝓕.States) {φs : List 𝓕.States}
lemma insertAndContract_uncontractedList_none_map (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
[φsΛ ↩Λ φ i none]ᵘᶜ = List.insertIdx (φsΛ.uncontractedListOrderPos i) φ [φsΛ]ᵘᶜ := by
simp only [Nat.succ_eq_add_one, insertAndContract, uncontractedListGet]
@ -305,14 +305,14 @@ lemma insertAndContract_uncontractedList_none_map (φ : 𝓕.States) {φs : List
rfl
@[simp]
lemma insertAndContract_uncontractedList_none_zero (φ : 𝓕.States) {φs : List 𝓕.States}
lemma insertAndContract_uncontractedList_none_zero (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) :
[φsΛ ↩Λ φ 0 none]ᵘᶜ = φ :: [φsΛ]ᵘᶜ := by
rw [insertAndContract_uncontractedList_none_map]
simp [uncontractedListOrderPos]
open FieldStatistic in
lemma stat_ofFinset_of_insertAndContractLiftFinset (φ : 𝓕.States) (φs : List 𝓕.States)
lemma stat_ofFinset_of_insertAndContractLiftFinset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(i : Fin φs.length.succ) (a : Finset (Fin φs.length)) :
(𝓕 |>ₛ ⟨(φs.insertIdx i φ).get, insertAndContractLiftFinset φ i a⟩) = 𝓕 |>ₛ ⟨φs.get, a⟩ := by
simp only [ofFinset, Nat.succ_eq_add_one]

84
HepLean/PerturbationTheory/WickContraction/Join.lean
View file

@ -26,7 +26,7 @@ open FieldOpAlgebra
/-- Given a Wick contraction `φsΛ` on `φs` and a Wick contraction `φsucΛ` on the uncontracted fields
within `φsΛ`, a Wick contraction on `φs`consisting of the contractins in `φsΛ` and
the contractions in `φsucΛ`. -/
def join {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
def join {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) : WickContraction φs.length :=
⟨φsΛ.1 ∪ φsucΛ.1.map (Finset.mapEmbedding uncontractedListEmd).toEmbedding, by
intro a ha
@ -61,7 +61,7 @@ def join {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
rw [Finset.disjoint_map]
exact φsucΛ.2.2 a ha b hb⟩
lemma join_congr {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma join_congr {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} {φsΛ' : WickContraction φs.length}
(h1 : φsΛ = φsΛ') :
join φsΛ φsucΛ = join φsΛ' (congr (by simp [h1]) φsucΛ) := by
@ -70,11 +70,11 @@ lemma join_congr {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
/-- Given a contracting pair within `φsΛ` the corresponding contracting pair within
`(join φsΛ φsucΛ)`. -/
def joinLiftLeft {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
def joinLiftLeft {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : φsΛ.1 → (join φsΛ φsucΛ).1 :=
fun a => ⟨a, by simp [join]⟩
lemma jointLiftLeft_injective {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma jointLiftLeft_injective {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} :
Function.Injective (@joinLiftLeft _ _ φsΛ φsucΛ) := by
intro a b h
@ -84,7 +84,7 @@ lemma jointLiftLeft_injective {φs : List 𝓕.States} {φsΛ : WickContraction
/-- Given a contracting pair within `φsucΛ` the corresponding contracting pair within
`(join φsΛ φsucΛ)`. -/
def joinLiftRight {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
def joinLiftRight {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : φsucΛ.1 → (join φsΛ φsucΛ).1 :=
fun a => ⟨a.1.map uncontractedListEmd, by
simp only [join, Finset.le_eq_subset, Finset.mem_union, Finset.mem_map,
@ -94,7 +94,7 @@ def joinLiftRight {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
simp only [Finset.coe_mem, true_and]
rfl⟩
lemma joinLiftRight_injective {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma joinLiftRight_injective {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} :
Function.Injective (@joinLiftRight _ _ φsΛ φsucΛ) := by
intro a b h
@ -103,7 +103,7 @@ lemma joinLiftRight_injective {φs : List 𝓕.States} {φsΛ : WickContraction
simp only [Finset.map_inj] at h
refine Subtype.eq h
lemma jointLiftLeft_disjoint_joinLiftRight {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma jointLiftLeft_disjoint_joinLiftRight {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} (a : φsΛ.1) (b : φsucΛ.1) :
Disjoint (@joinLiftLeft _ _ _ φsucΛ a).1 (joinLiftRight b).1 := by
simp only [joinLiftLeft, joinLiftRight]
@ -111,7 +111,7 @@ lemma jointLiftLeft_disjoint_joinLiftRight {φs : List 𝓕.States} {φsΛ : Wic
apply uncontractedListEmd_finset_disjoint_left
exact a.2
lemma jointLiftLeft_neq_joinLiftRight {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma jointLiftLeft_neq_joinLiftRight {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} (a : φsΛ.1) (b : φsucΛ.1) :
joinLiftLeft a ≠ joinLiftRight b := by
by_contra hn
@ -124,13 +124,13 @@ lemma jointLiftLeft_neq_joinLiftRight {φs : List 𝓕.States} {φsΛ : WickCont
/-- The map from contracted pairs of `φsΛ` and `φsucΛ` to contracted pairs in
`(join φsΛ φsucΛ)`. -/
def joinLift {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
def joinLift {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : φsΛ.1 ⊕ φsucΛ.1 → (join φsΛ φsucΛ).1 := fun a =>
match a with
| Sum.inl a => joinLiftLeft a
| Sum.inr a => joinLiftRight a
lemma joinLift_injective {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma joinLift_injective {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : Function.Injective (@joinLift _ _ φsΛ φsucΛ) := by
intro a b h
match a, b with
@ -149,7 +149,7 @@ lemma joinLift_injective {φs : List 𝓕.States} {φsΛ : WickContraction φs.l
have h1 := jointLiftLeft_neq_joinLiftRight b a
simp_all
lemma joinLift_surjective {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma joinLift_surjective {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : Function.Surjective (@joinLift _ _ φsΛ φsucΛ) := by
intro a
have ha2 := a.2
@ -164,13 +164,13 @@ lemma joinLift_surjective {φs : List 𝓕.States} {φsΛ : WickContraction φs.
refine Subtype.eq ?_
exact ha3.2
lemma joinLift_bijective {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma joinLift_bijective {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} : Function.Bijective (@joinLift _ _ φsΛ φsucΛ) := by
apply And.intro
· exact joinLift_injective
· exact joinLift_surjective
lemma prod_join {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma prod_join {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (f : (join φsΛ φsucΛ).1 → M) [CommMonoid M]:
∏ (a : (join φsΛ φsucΛ).1), f a = (∏ (a : φsΛ.1), f (joinLiftLeft a)) *
∏ (a : φsucΛ.1), f (joinLiftRight a) := by
@ -179,7 +179,7 @@ lemma prod_join {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
simp only [Fintype.prod_sum_type, Finset.univ_eq_attach]
rfl
lemma joinLiftLeft_or_joinLiftRight_of_mem_join {φs : List 𝓕.States}
lemma joinLiftLeft_or_joinLiftRight_of_mem_join {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) {a : Finset (Fin φs.length)}
(ha : a ∈ (join φsΛ φsucΛ).1) :
@ -196,7 +196,7 @@ lemma joinLiftLeft_or_joinLiftRight_of_mem_join {φs : List 𝓕.States}
rfl
@[simp]
lemma join_fstFieldOfContract_joinLiftRight {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_fstFieldOfContract_joinLiftRight {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (a : φsucΛ.1) :
(join φsΛ φsucΛ).fstFieldOfContract (joinLiftRight a) =
uncontractedListEmd (φsucΛ.fstFieldOfContract a) := by
@ -207,7 +207,7 @@ lemma join_fstFieldOfContract_joinLiftRight {φs : List 𝓕.States} (φsΛ : Wi
exact fstFieldOfContract_lt_sndFieldOfContract φsucΛ a
@[simp]
lemma join_sndFieldOfContract_joinLiftRight {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_sndFieldOfContract_joinLiftRight {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (a : φsucΛ.1) :
(join φsΛ φsucΛ).sndFieldOfContract (joinLiftRight a) =
uncontractedListEmd (φsucΛ.sndFieldOfContract a) := by
@ -218,7 +218,7 @@ lemma join_sndFieldOfContract_joinLiftRight {φs : List 𝓕.States} (φsΛ : Wi
exact fstFieldOfContract_lt_sndFieldOfContract φsucΛ a
@[simp]
lemma join_fstFieldOfContract_joinLiftLeft {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_fstFieldOfContract_joinLiftLeft {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (a : φsΛ.1) :
(join φsΛ φsucΛ).fstFieldOfContract (joinLiftLeft a) =
(φsΛ.fstFieldOfContract a) := by
@ -228,7 +228,7 @@ lemma join_fstFieldOfContract_joinLiftLeft {φs : List 𝓕.States} (φsΛ : Wic
· exact fstFieldOfContract_lt_sndFieldOfContract φsΛ a
@[simp]
lemma join_sndFieldOfContract_joinLift {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_sndFieldOfContract_joinLift {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (a : φsΛ.1) :
(join φsΛ φsucΛ).sndFieldOfContract (joinLiftLeft a) =
(φsΛ.sndFieldOfContract a) := by
@ -237,7 +237,7 @@ lemma join_sndFieldOfContract_joinLift {φs : List 𝓕.States} (φsΛ : WickCon
· simp [joinLiftLeft]
· exact fstFieldOfContract_lt_sndFieldOfContract φsΛ a
lemma mem_join_right_iff {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma mem_join_right_iff {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (a : Finset (Fin [φsΛ]ᵘᶜ.length)) :
a ∈ φsucΛ.1 ↔ a.map uncontractedListEmd ∈ (join φsΛ φsucΛ).1 := by
simp only [join, Finset.le_eq_subset, Finset.mem_union, Finset.mem_map,
@ -257,7 +257,7 @@ lemma mem_join_right_iff {φs : List 𝓕.States} (φsΛ : WickContraction φs.l
subst h2
exact ha
lemma join_card {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma join_card {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{φsucΛ : WickContraction [φsΛ]ᵘᶜ.length} :
(join φsΛ φsucΛ).1.card = φsΛ.1.card + φsucΛ.1.card := by
simp only [join, Finset.le_eq_subset]
@ -277,7 +277,7 @@ lemma join_card {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
simp_all
@[simp]
lemma empty_join {φs : List 𝓕.States} (φsΛ : WickContraction [empty (n := φs.length)]ᵘᶜ.length) :
lemma empty_join {φs : List 𝓕.FieldOp} (φsΛ : WickContraction [empty (n := φs.length)]ᵘᶜ.length) :
join empty φsΛ = congr (by simp) φsΛ := by
apply Subtype.ext
simp only [join, Finset.le_eq_subset, uncontractedListEmd_empty]
@ -306,13 +306,13 @@ lemma empty_join {φs : List 𝓕.States} (φsΛ : WickContraction [empty (n :=
simp
@[simp]
lemma join_empty {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
lemma join_empty {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
join φsΛ empty = φsΛ := by
apply Subtype.ext
ext a
simp [join, empty]
lemma join_timeContract {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_timeContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).timeContract = φsΛ.timeContract * φsucΛ.timeContract := by
simp only [timeContract, List.get_eq_getElem]
@ -322,7 +322,7 @@ lemma join_timeContract {φs : List 𝓕.States} (φsΛ : WickContraction φs.le
funext a
simp
lemma join_staticContract {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_staticContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).staticContract = φsΛ.staticContract * φsucΛ.staticContract := by
simp only [staticContract, List.get_eq_getElem]
@ -332,7 +332,7 @@ lemma join_staticContract {φs : List 𝓕.States} (φsΛ : WickContraction φs.
funext a
simp
lemma mem_join_uncontracted_of_mem_right_uncontracted {φs : List 𝓕.States}
lemma mem_join_uncontracted_of_mem_right_uncontracted {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin [φsΛ]ᵘᶜ.length)
(ha : i ∈ φsucΛ.uncontracted) :
@ -352,7 +352,7 @@ lemma mem_join_uncontracted_of_mem_right_uncontracted {φs : List 𝓕.States}
rw [mem_uncontracted_iff_not_contracted] at ha
exact ha p hp
lemma exists_mem_left_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.States}
lemma exists_mem_left_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin φs.length)
(ha : i ∈ (join φsΛ φsucΛ).uncontracted) :
@ -364,7 +364,7 @@ lemma exists_mem_left_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.Sta
intro p hp
simp_all
lemma exists_mem_right_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.States}
lemma exists_mem_right_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin φs.length)
(hi : i ∈ (join φsΛ φsucΛ).uncontracted) :
@ -385,7 +385,7 @@ lemma exists_mem_right_uncontracted_of_mem_join_uncontracted {φs : List 𝓕.St
rw [Finset.mapEmbedding_apply])
simpa using hip
lemma join_uncontractedList {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_uncontractedList {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).uncontractedList = List.map uncontractedListEmd φsucΛ.uncontractedList := by
rw [uncontractedList_eq_sort]
@ -404,7 +404,7 @@ lemma join_uncontractedList {φs : List 𝓕.States} (φsΛ : WickContraction φ
· intro a b h
exact uncontractedListEmd_strictMono h
lemma join_uncontractedList_get {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_uncontractedList_get {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
((join φsΛ φsucΛ).uncontractedList).get =
φsΛ.uncontractedListEmd ∘ (φsucΛ.uncontractedList).get ∘
@ -417,7 +417,7 @@ lemma join_uncontractedList_get {φs : List 𝓕.States} (φsΛ : WickContractio
ext i
simp
lemma join_uncontractedListGet {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_uncontractedListGet {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).uncontractedListGet = φsucΛ.uncontractedListGet := by
simp only [uncontractedListGet, join_uncontractedList, List.map_map, List.map_inj_left,
@ -428,7 +428,7 @@ lemma join_uncontractedListGet {φs : List 𝓕.States} (φsΛ : WickContraction
Function.Embedding.coe_subtype]
rfl
lemma join_uncontractedListEmb {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_uncontractedListEmb {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).uncontractedListEmd =
((finCongr (congrArg List.length (join_uncontractedListGet _ _))).toEmbedding.trans
@ -439,7 +439,7 @@ lemma join_uncontractedListEmb {φs : List 𝓕.States} (φsΛ : WickContraction
rw [join_uncontractedList_get]
rfl
lemma join_assoc {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_assoc {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (φsucΛ' : WickContraction [φsΛ.join φsucΛ]ᵘᶜ.length) :
join (join φsΛ φsucΛ) (φsucΛ') = join φsΛ (join φsucΛ (congr
(congrArg List.length (join_uncontractedListGet _ _)) φsucΛ')) := by
@ -490,7 +490,7 @@ lemma join_assoc {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
change Finset.map (Equiv.refl _).toEmbedding a = _
simp only [Equiv.refl_toEmbedding, Finset.map_refl]
lemma join_getDual?_apply_uncontractedListEmb_eq_none_iff {φs : List 𝓕.States}
lemma join_getDual?_apply_uncontractedListEmb_eq_none_iff {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).getDual? (uncontractedListEmd i) = none
@ -506,7 +506,7 @@ lemma join_getDual?_apply_uncontractedListEmb_eq_none_iff {φs : List 𝓕.State
· intro h
exact mem_join_uncontracted_of_mem_right_uncontracted φsΛ φsucΛ i h
lemma join_getDual?_apply_uncontractedListEmb_isSome_iff {φs : List 𝓕.States}
lemma join_getDual?_apply_uncontractedListEmb_isSome_iff {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin [φsΛ]ᵘᶜ.length) :
((join φsΛ φsucΛ).getDual? (uncontractedListEmd i)).isSome
@ -514,7 +514,7 @@ lemma join_getDual?_apply_uncontractedListEmb_isSome_iff {φs : List 𝓕.States
rw [← Decidable.not_iff_not]
simp [join_getDual?_apply_uncontractedListEmb_eq_none_iff]
lemma join_getDual?_apply_uncontractedListEmb_some {φs : List 𝓕.States}
lemma join_getDual?_apply_uncontractedListEmb_some {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin [φsΛ]ᵘᶜ.length)
(hi :((join φsΛ φsucΛ).getDual? (uncontractedListEmd i)).isSome) :
@ -532,7 +532,7 @@ lemma join_getDual?_apply_uncontractedListEmb_some {φs : List 𝓕.States}
simp
@[simp]
lemma join_getDual?_apply_uncontractedListEmb {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_getDual?_apply_uncontractedListEmb {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i : Fin [φsΛ]ᵘᶜ.length) :
((join φsΛ φsucΛ).getDual? (uncontractedListEmd i)) =
Option.map uncontractedListEmd (φsucΛ.getDual? i) := by
@ -556,7 +556,7 @@ lemma join_getDual?_apply_uncontractedListEmb {φs : List 𝓕.States} (φsΛ :
section
variable {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
variable {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
lemma join_sub_quot (S : Finset (Finset (Fin φs.length))) (ha : S ⊆ φsΛ.1) :
join (subContraction S ha) (quotContraction S ha) = φsΛ := by
@ -590,7 +590,7 @@ end
open FieldStatistic
@[simp]
lemma join_singleton_getDual?_left {φs : List 𝓕.States}
lemma join_singleton_getDual?_left {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(join (singleton h) φsucΛ).getDual? i = some j := by
@ -598,7 +598,7 @@ lemma join_singleton_getDual?_left {φs : List 𝓕.States}
simp [singleton, join]
@[simp]
lemma join_singleton_getDual?_right {φs : List 𝓕.States}
lemma join_singleton_getDual?_right {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(join (singleton h) φsucΛ).getDual? j = some i := by
@ -609,12 +609,12 @@ lemma join_singleton_getDual?_right {φs : List 𝓕.States}
exact Finset.pair_comm j i
lemma exists_contraction_pair_of_card_ge_zero {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma exists_contraction_pair_of_card_ge_zero {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(h : 0 < φsΛ.1.card) :
∃ a, a ∈ φsΛ.1 := by
simpa using h
lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(h : 0 < φsΛ.1.card) (hc : φsΛ.GradingCompliant) :
∃ (i j : Fin φs.length) (h : i < j) (φsucΛ : WickContraction [singleton h]ᵘᶜ.length),
φsΛ = join (singleton h) φsucΛ ∧ (𝓕 |>ₛ φs[i]) = (𝓕 |>ₛ φs[j])
@ -645,7 +645,7 @@ lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.States} (φsΛ : Wi
simp only [subContraction, Finset.card_singleton, id_eq, eq_mpr_eq_cast] at h1
omega
lemma join_not_gradingCompliant_of_left_not_gradingCompliant {φs : List 𝓕.States}
lemma join_not_gradingCompliant_of_left_not_gradingCompliant {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) (φsucΛ : WickContraction [φsΛ]ᵘᶜ.length)
(hc : ¬ φsΛ.GradingCompliant) : ¬ (join φsΛ φsucΛ).GradingCompliant := by
simp_all only [GradingCompliant, Fin.getElem_fin, Subtype.forall, not_forall]

6
HepLean/PerturbationTheory/WickContraction/Sign/Basic.lean
View file

@ -32,16 +32,16 @@ def signFinset (c : WickContraction n) (i1 i2 : Fin n) : Finset (Fin n) :=
the sign associated with `φsΛ` is sign corresponding to the number
of fermionic-fermionic exchanges one must do to put elements in contracted pairs
of `φsΛ` next to each other. -/
def sign (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) : ℂ :=
def sign (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : ℂ :=
∏ (a : φsΛ.1), 𝓢(𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a],
𝓕 |>ₛ ⟨φs.get, φsΛ.signFinset (φsΛ.fstFieldOfContract a) (φsΛ.sndFieldOfContract a)⟩)
lemma sign_empty (φs : List 𝓕.States) :
lemma sign_empty (φs : List 𝓕.FieldOp) :
sign φs empty = 1 := by
rw [sign]
simp [empty]
lemma sign_congr {φs φs' : List 𝓕.States} (h : φs = φs') (φsΛ : WickContraction φs.length) :
lemma sign_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs') (φsΛ : WickContraction φs.length) :
sign φs' (congr (by simp [h]) φsΛ) = sign φs φsΛ := by
subst h
rfl

18
HepLean/PerturbationTheory/WickContraction/Sign/InsertNone.lean
View file

@ -19,7 +19,7 @@ variable {n : ℕ} (c : WickContraction n)
open HepLean.List
open FieldStatistic
lemma signFinset_insertAndContract_none (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signFinset_insertAndContract_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (i1 i2 : Fin φs.length) :
(φsΛ ↩Λ φ i none).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
@ -81,14 +81,14 @@ lemma signFinset_insertAndContract_none (φ : 𝓕.States) (φs : List 𝓕.Stat
For each contracted pair `{a1, a2}` in `φsΛ` if `a1 < a2` such that `i` is within the range
`a1 < i < a2` we pick up a sign equal to `𝓢(φ, φs[a2])`. -/
def signInsertNone (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
def signInsertNone (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) : ℂ :=
∏ (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) (φsΛ : WickContraction φs.length)
lemma sign_insert_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) :
(φsΛ ↩Λ φ i none).sign = (φsΛ.signInsertNone φ φs i) * φsΛ.sign := by
rw [sign]
@ -109,7 +109,7 @@ lemma sign_insert_none (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : Wick
simp
· rw [stat_ofFinset_of_insertAndContractLiftFinset]
lemma signInsertNone_eq_mul_fst_snd (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertNone_eq_mul_fst_snd (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
φsΛ.signInsertNone φ φs i = ∏ (a : φsΛ.1),
(if i.succAbove (φsΛ.fstFieldOfContract a) < i then
@ -143,7 +143,7 @@ lemma signInsertNone_eq_mul_fst_snd (φ : 𝓕.States) (φs : List 𝓕.States)
have hx := (Fin.succAbove_lt_succAbove_iff (p := i)).mpr hn
omega
lemma signInsertNone_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertNone_eq_prod_prod (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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
@ -158,12 +158,12 @@ lemma signInsertNone_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
erw [hG a]
rfl
lemma sign_insert_none_zero (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) :
lemma sign_insert_none_zero (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) :
(φsΛ ↩Λ φ 0 none).sign = φsΛ.sign := by
rw [sign_insert_none]
simp [signInsertNone]
lemma signInsertNone_eq_prod_getDual?_Some (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertNone_eq_prod_getDual?_Some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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
@ -190,7 +190,7 @@ lemma signInsertNone_eq_prod_getDual?_Some (φ : 𝓕.States) (φs : List 𝓕.S
rfl
exact hG
lemma signInsertNone_eq_filter_map (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertNone_eq_filter_map (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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)
@ -216,7 +216,7 @@ lemma signInsertNone_eq_filter_map (φ : 𝓕.States) (φs : List 𝓕.States)
/-- The change in sign when inserting a field `φ` at `i` into `φsΛ` is equal
to the sign got by moving `φ` through each field `φ₀…φᵢ₋₁` which has a dual. -/
lemma signInsertNone_eq_filterset (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertNone_eq_filterset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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

34
HepLean/PerturbationTheory/WickContraction/Sign/InsertSome.lean
View file

@ -27,7 +27,7 @@ open FieldStatistic
-/
lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.States)
lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.FieldOp)
(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) :
@ -64,7 +64,7 @@ lemma stat_ofFinset_eq_one_of_gradingCompliant (φs : List 𝓕.States)
rfl
lemma signFinset_insertAndContract_some (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signFinset_insertAndContract_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (i1 i2 : Fin φs.length)
(j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).signFinset (finCongr (insertIdx_length_fin φ φs i).symm
@ -206,7 +206,7 @@ lemma signFinset_insertAndContract_some (φ : 𝓕.States) (φs : List 𝓕.Stat
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) (φsΛ : WickContraction φs.length)
def signInsertSomeProd (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φ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) ∧
@ -223,7 +223,7 @@ def signInsertSomeProd (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : Wick
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) (φsΛ : WickContraction φs.length)
def signInsertSomeCoef (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) : ℂ :=
let a : (φsΛ ↩Λ φ i (some j)).1 := congrLift (insertIdx_length_fin φ φs i).symm
⟨{i, i.succAbove j}, by simp [insertAndContractNat]⟩;
@ -235,11 +235,11 @@ def signInsertSomeCoef (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : Wick
/-- Given a Wick contraction `φsΛ` 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) (φsΛ : WickContraction φs.length)
def signInsertSome (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φ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) (φsΛ : WickContraction φs.length)
lemma sign_insert_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).sign = (φsΛ.signInsertSome φ φs i j) * φsΛ.sign := by
rw [sign]
@ -280,7 +280,7 @@ lemma sign_insert_some (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : Wick
rw [stat_ofFinset_of_insertAndContractLiftFinset]
simp_all
lemma signInsertSomeProd_eq_one_if (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeProd_eq_one_if (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted)
(hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1])) :
φsΛ.signInsertSomeProd φ φs i j =
@ -313,7 +313,7 @@ lemma signInsertSomeProd_eq_one_if (φ : 𝓕.States) (φs : List 𝓕.States)
implies_true, and_true]
omega
lemma signInsertSomeProd_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeProd_eq_prod_prod (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
(hg : GradingCompliant φs φsΛ) :
@ -347,7 +347,7 @@ lemma signInsertSomeProd_eq_prod_prod (φ : 𝓕.States) (φs : List 𝓕.States
· omega
simp [hφj]
lemma signInsertSomeProd_eq_prod_fin (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeProd_eq_prod_fin (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
(hg : GradingCompliant φs φsΛ) :
@ -380,7 +380,7 @@ lemma signInsertSomeProd_eq_prod_fin (φ : 𝓕.States) (φs : List 𝓕.States)
simp only [hφj, Fin.getElem_fin]
exact hg
lemma signInsertSomeProd_eq_list (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeProd_eq_list (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
(hg : GradingCompliant φs φsΛ) :
@ -414,7 +414,7 @@ lemma signInsertSomeProd_eq_list (φ : 𝓕.States) (φs : List 𝓕.States)
simp only [hφj, Fin.getElem_fin]
exact hg
lemma signInsertSomeProd_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeProd_eq_finset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) (hφj : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[j.1]))
(hg : GradingCompliant φs φsΛ) :
@ -442,7 +442,7 @@ lemma signInsertSomeProd_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
simp only [hφj, Fin.getElem_fin]
exact hg
lemma signInsertSomeCoef_if (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
lemma signInsertSomeCoef_if (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φ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
@ -462,7 +462,7 @@ lemma signInsertSomeCoef_if (φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ :
· simp [hφj]
lemma stat_signFinset_insert_some_self_fst
(φ : 𝓕.States) (φs : List 𝓕.States) (φsΛ : WickContraction φs.length)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length)
(i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
(signFinset (φsΛ ↩Λ φ i (some j)) (finCongr (insertIdx_length_fin φ φs i).symm i)
@ -538,7 +538,7 @@ lemma stat_signFinset_insert_some_self_fst
have hy2 := hy2 h
simpa [Option.get_map] using hy2
lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.States) (φs : List 𝓕.States)
lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(𝓕 |>ₛ ⟨(φs.insertIdx i φ).get,
(signFinset (φsΛ ↩Λ φ i (some j))
@ -618,7 +618,7 @@ lemma stat_signFinset_insert_some_self_snd (φ : 𝓕.States) (φs : List 𝓕.S
simp only [Option.get_map, Function.comp_apply, Fin.coe_cast, Fin.val_fin_lt]
exact Fin.succAbove_lt_succAbove_iff.mpr hy2
lemma signInsertSomeCoef_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSomeCoef_eq_finset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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
@ -637,7 +637,7 @@ lemma signInsertSomeCoef_eq_finset (φ : 𝓕.States) (φs : List 𝓕.States)
contracting it with `k` (`k < i`) is equal
to the sign got by moving `φ` through each field `φ₀…φᵢ₋₁`
multiplied by the sign got moving `φ` through each uncontracted field `φ₀…φₖ`. -/
lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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 *
@ -744,7 +744,7 @@ lemma signInsertSome_mul_filter_contracted_of_lt (φ : 𝓕.States) (φs : List
contracting it with `k` (`i < k`) is equal
to the sign got by moving `φ` through each field `φ₀…φᵢ₋₁`
multiplied by the sign got moving `φ` through each uncontracted field `φ₀…φₖ₋₁`. -/
lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.States) (φs : List 𝓕.States)
lemma signInsertSome_mul_filter_contracted_of_not_lt (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φ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 *

30
HepLean/PerturbationTheory/WickContraction/Sign/Join.lean
View file

@ -20,7 +20,7 @@ open FieldOpAlgebra
open FieldStatistic
lemma stat_signFinset_right {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma stat_signFinset_right {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (i j : Fin [φsΛ]ᵘᶜ.length) :
(𝓕 |>ₛ ⟨[φsΛ]ᵘᶜ.get, φsucΛ.signFinset i j⟩) =
(𝓕 |>ₛ ⟨φs.get, (φsucΛ.signFinset i j).map uncontractedListEmd⟩) := by
@ -32,7 +32,7 @@ lemma stat_signFinset_right {φs : List 𝓕.States} (φsΛ : WickContraction φ
intro i j h
exact uncontractedListEmd_strictMono h
lemma signFinset_right_map_uncontractedListEmd_eq_filter {φs : List 𝓕.States}
lemma signFinset_right_map_uncontractedListEmd_eq_filter {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) (φsucΛ : WickContraction [φsΛ]ᵘᶜ.length)
(i j : Fin [φsΛ]ᵘᶜ.length) : (φsucΛ.signFinset i j).map uncontractedListEmd =
((join φsΛ φsucΛ).signFinset (uncontractedListEmd i) (uncontractedListEmd j)).filter
@ -90,7 +90,7 @@ lemma signFinset_right_map_uncontractedListEmd_eq_filter {φs : List 𝓕.States
exact hl
exact fun _ _ h => uncontractedListEmd_strictMono h
lemma sign_right_eq_prod_mul_prod {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma sign_right_eq_prod_mul_prod {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
φsucΛ.sign = (∏ a, 𝓢(𝓕|>ₛ [φsΛ]ᵘᶜ[φsucΛ.sndFieldOfContract a], 𝓕|>ₛ ⟨φs.get,
((join φsΛ φsucΛ).signFinset (uncontractedListEmd (φsucΛ.fstFieldOfContract a))
@ -107,7 +107,7 @@ lemma sign_right_eq_prod_mul_prod {φs : List 𝓕.States} (φsΛ : WickContract
rw [stat_signFinset_right, signFinset_right_map_uncontractedListEmd_eq_filter]
rw [ofFinset_filter]
lemma join_singleton_signFinset_eq_filter {φs : List 𝓕.States}
lemma join_singleton_signFinset_eq_filter {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(join (singleton h) φsucΛ).signFinset i j =
@ -149,7 +149,7 @@ lemma join_singleton_signFinset_eq_filter {φs : List 𝓕.States}
· simp only [Bool.not_eq_true, Option.not_isSome, Option.isNone_iff_eq_none] at h2'
simp [h2']
lemma join_singleton_left_signFinset_eq_filter {φs : List 𝓕.States}
lemma join_singleton_left_signFinset_eq_filter {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(𝓕 |>ₛ ⟨φs.get, (singleton h).signFinset i j⟩)
@ -166,7 +166,7 @@ lemma join_singleton_left_signFinset_eq_filter {φs : List 𝓕.States}
/-- The difference in sign between `φsucΛ.sign` and the direct contribution of `φsucΛ` to
`(join (singleton h) φsucΛ)`. -/
def joinSignRightExtra {φs : List 𝓕.States}
def joinSignRightExtra {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) : ℂ :=
∏ a, 𝓢(𝓕|>ₛ [singleton h]ᵘᶜ[φsucΛ.sndFieldOfContract a], 𝓕|>ₛ ⟨φs.get,
@ -176,7 +176,7 @@ def joinSignRightExtra {φs : List 𝓕.States}
/-- The difference in sign between `(singleton h).sign` and the direct contribution of
`(singleton h)` to `(join (singleton h) φsucΛ)`. -/
def joinSignLeftExtra {φs : List 𝓕.States}
def joinSignLeftExtra {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) : ℂ :=
𝓢(𝓕 |>ₛ φs[j], (𝓕 |>ₛ ⟨φs.get, ((singleton h).signFinset i j).filter (fun c =>
@ -184,7 +184,7 @@ def joinSignLeftExtra {φs : List 𝓕.States}
((h1 : ((join (singleton h) φsucΛ).getDual? c).isSome) →
(((join (singleton h) φsucΛ).getDual? c).get h1) < i)))⟩))
lemma join_singleton_sign_left {φs : List 𝓕.States}
lemma join_singleton_sign_left {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(singleton h).sign = 𝓢(𝓕 |>ₛ φs[j],
@ -194,7 +194,7 @@ lemma join_singleton_sign_left {φs : List 𝓕.States}
rw [map_mul]
rfl
lemma join_singleton_sign_right {φs : List 𝓕.States}
lemma join_singleton_sign_right {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
φsucΛ.sign =
@ -206,7 +206,7 @@ lemma join_singleton_sign_right {φs : List 𝓕.States}
rfl
lemma joinSignRightExtra_eq_i_j_finset_eq_if {φs : List 𝓕.States}
lemma joinSignRightExtra_eq_i_j_finset_eq_if {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j)
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
joinSignRightExtra h φsucΛ = ∏ a,
@ -298,7 +298,7 @@ lemma joinSignRightExtra_eq_i_j_finset_eq_if {φs : List 𝓕.States}
Option.get_some, forall_const, false_or, true_and]
omega
lemma joinSignLeftExtra_eq_joinSignRightExtra {φs : List 𝓕.States}
lemma joinSignLeftExtra_eq_joinSignRightExtra {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j) (hs : (𝓕 |>ₛ φs[i]) = (𝓕 |>ₛ φs[j]))
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
joinSignLeftExtra h φsucΛ = joinSignRightExtra h φsucΛ := by
@ -380,7 +380,7 @@ lemma joinSignLeftExtra_eq_joinSignRightExtra {φs : List 𝓕.States}
simp only [Finset.disjoint_singleton_right, Finset.mem_singleton]
exact Fin.ne_of_lt h
lemma join_sign_singleton {φs : List 𝓕.States}
lemma join_sign_singleton {φs : List 𝓕.FieldOp}
{i j : Fin φs.length} (h : i < j) (hs : (𝓕 |>ₛ φs[i]) = (𝓕 |>ₛ φs[j]))
(φsucΛ : WickContraction [singleton h]ᵘᶜ.length) :
(join (singleton h) φsucΛ).sign = (singleton h).sign * φsucΛ.sign := by
@ -401,7 +401,7 @@ lemma join_sign_singleton {φs : List 𝓕.States}
· funext a
simp
lemma join_sign_induction {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_sign_induction {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (hc : φsΛ.GradingCompliant) :
(n : ℕ) → (hn : φsΛ.1.card = n) →
(join φsΛ φsucΛ).sign = φsΛ.sign * φsucΛ.sign
@ -428,12 +428,12 @@ lemma join_sign_induction {φs : List 𝓕.States} (φsΛ : WickContraction φs.
apply sign_congr
exact join_uncontractedListGet (singleton hij) φsucΛ'
lemma join_sign {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_sign {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (hc : φsΛ.GradingCompliant) :
(join φsΛ φsucΛ).sign = φsΛ.sign * φsucΛ.sign := by
exact join_sign_induction φsΛ φsucΛ hc (φsΛ).1.card rfl
lemma join_sign_timeContract {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_sign_timeContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
(join φsΛ φsucΛ).sign • (join φsΛ φsucΛ).timeContract.1 =
(φsΛ.sign • φsΛ.timeContract.1) * (φsucΛ.sign • φsucΛ.timeContract.1) := by

14
HepLean/PerturbationTheory/WickContraction/Singleton.lean
View file

@ -46,7 +46,7 @@ lemma of_singleton_eq {i j : Fin n} (hij : i < j) (a : (singleton hij).1) :
rw [@mem_singleton_iff] at ha2
exact Subtype.coe_eq_of_eq_mk ha2
lemma singleton_prod {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j)
lemma singleton_prod {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j)
(f : (singleton hij).1 → M) [CommMonoid M] :
∏ a, f a = f ⟨{i,j}, mem_singleton hij⟩:= by
simp [singleton, of_singleton_eq]
@ -67,7 +67,7 @@ lemma singleton_sndFieldOfContract {i j : Fin n} (hij : i < j) :
· simp
· exact hij
lemma singleton_sign_expand {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j) :
lemma singleton_sign_expand {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j) :
(singleton hij).sign = 𝓢(𝓕 |>ₛ φs[j], 𝓕 |>ₛ ⟨φs.get, (singleton hij).signFinset i j⟩) := by
rw [sign, singleton_prod]
simp
@ -79,7 +79,7 @@ lemma singleton_getDual?_eq_none_iff_neq {i j : Fin n} (hij : i < j) (a : Fin n)
simp only [singleton, Finset.mem_singleton, forall_eq, Finset.mem_insert, not_or, ne_eq]
omega
lemma singleton_uncontractedEmd_neq_left {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j)
lemma singleton_uncontractedEmd_neq_left {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j)
(a : Fin [singleton hij]ᵘᶜ.length) :
(singleton hij).uncontractedListEmd a ≠ i := by
by_contra hn
@ -90,7 +90,7 @@ lemma singleton_uncontractedEmd_neq_left {φs : List 𝓕.States} {i j : Fin φs
simp [singleton]
simp_all
lemma singleton_uncontractedEmd_neq_right {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j)
lemma singleton_uncontractedEmd_neq_right {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j)
(a : Fin [singleton hij]ᵘᶜ.length) :
(singleton hij).uncontractedListEmd a ≠ j := by
by_contra hn
@ -111,7 +111,7 @@ lemma mem_signFinset {i j : Fin n} (hij : i < j) (a : Fin n) :
apply Or.inl
omega
lemma subContraction_singleton_eq_singleton {φs : List 𝓕.States}
lemma subContraction_singleton_eq_singleton {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(a : φsΛ.1) : φsΛ.subContraction {a.1} (by simp) =
singleton (φsΛ.fstFieldOfContract_lt_sndFieldOfContract a) := by
@ -119,13 +119,13 @@ lemma subContraction_singleton_eq_singleton {φs : List 𝓕.States}
simp only [subContraction, singleton, Finset.singleton_inj]
exact finset_eq_fstFieldOfContract_sndFieldOfContract φsΛ a
lemma singleton_timeContract {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j) :
lemma singleton_timeContract {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j) :
(singleton hij).timeContract =
⟨FieldOpAlgebra.timeContract φs[i] φs[j], timeContract_mem_center _ _⟩ := by
rw [timeContract, singleton_prod]
simp
lemma singleton_staticContract {φs : List 𝓕.States} {i j : Fin φs.length} (hij : i < j) :
lemma singleton_staticContract {φs : List 𝓕.FieldOp} {i j : Fin φs.length} (hij : i < j) :
(singleton hij).staticContract.1 =
[anPart φs[i], ofFieldOp φs[j]]ₛ := by
rw [staticContract, singleton_prod]

14
HepLean/PerturbationTheory/WickContraction/StaticContract.lean
View file

@ -21,7 +21,7 @@ open FieldOpAlgebra
/-- Given a Wick contraction `φsΛ` associated with a list `φs`, the
product of all time-contractions of pairs of contracted elements in `φs`,
as a member of the center of `𝓞.A`. -/
noncomputable def staticContract {φs : List 𝓕.States}
noncomputable def staticContract {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) :
Subalgebra.center ℂ 𝓕.FieldOpAlgebra :=
∏ (a : φsΛ.1), ⟨[anPart (φs.get (φsΛ.fstFieldOfContract a)),
@ -29,7 +29,7 @@ noncomputable def staticContract {φs : List 𝓕.States}
superCommute_anPart_ofFieldOp_mem_center _ _⟩
@[simp]
lemma staticContract_insertAndContract_none (φ : 𝓕.States) (φs : List 𝓕.States)
lemma staticContract_insertAndContract_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
(φsΛ ↩Λ φ i none).staticContract = φsΛ.staticContract := by
rw [staticContract, insertAndContract_none_prod_contractions]
@ -46,7 +46,7 @@ This follows from the fact that `(φsΛ ↩Λ φ i (some j))` has one more contr
corresponding to `φ` contracted with `φⱼ`. The order depends on whether we insert `φ` before
or after `φⱼ`. -/
lemma staticContract_insertAndContract_some
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).staticContract =
(if i < i.succAbove j then
@ -67,16 +67,16 @@ lemma staticContract_insertAndContract_some
open FieldStatistic
lemma staticConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
(hik : i < i.succAbove k) :
(φsΛ ↩Λ φ i (some k)).staticContract =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < k))⟩)
• (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedStatesEquiv φs φsΛ) (some k)) *
• (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) *
φsΛ.staticContract) := by
rw [staticContract_insertAndContract_some]
simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1,
contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
contractStateAtIndex, uncontractedFieldOpEquiv, 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, uncontractedListGet]
@ -97,7 +97,7 @@ lemma staticConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
rw [h1]
simp only [exchangeSign_mul_self]
lemma staticContract_of_not_gradingCompliant (φs : List 𝓕.States)
lemma staticContract_of_not_gradingCompliant (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (h : ¬ GradingCompliant φs φsΛ) :
φsΛ.staticContract = 0 := by
rw [staticContract]

2
HepLean/PerturbationTheory/WickContraction/SubContraction.lean
View file

@ -16,7 +16,7 @@ open FieldSpecification
variable {𝓕 : FieldSpecification}
namespace WickContraction
variable {n : ℕ} {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
variable {n : ℕ} {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
open HepLean.List
open FieldOpAlgebra

64
HepLean/PerturbationTheory/WickContraction/TimeCond.lean
View file

@ -20,16 +20,16 @@ open FieldOpAlgebra
/-- The condition on a Wick contraction which is true iff and only if every contraction
is between two fields of equal time. -/
def EqTimeOnly {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) : Prop :=
def EqTimeOnly {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : Prop :=
∀ (i j), {i, j} ∈ φsΛ.1 → timeOrderRel φs[i] φs[j]
noncomputable section
instance {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
instance {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
Decidable (EqTimeOnly φsΛ) :=
inferInstanceAs (Decidable (∀ (i j), {i, j} ∈ φsΛ.1 → timeOrderRel φs[i] φs[j]))
namespace EqTimeOnly
variable {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
variable {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
lemma timeOrderRel_of_eqTimeOnly_pair {i j : Fin φs.length} (h : {i, j} ∈ φsΛ.1)
(hc : EqTimeOnly φsΛ) :
@ -48,7 +48,7 @@ lemma timeOrderRel_both_of_eqTimeOnly {i j : Fin φs.length} (h : {i, j} ∈ φs
rw [@Finset.pair_comm]
exact h
lemma eqTimeOnly_iff_forall_finset {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
lemma eqTimeOnly_iff_forall_finset {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
φsΛ.EqTimeOnly ↔ ∀ (a : φsΛ.1),
timeOrderRel (φs[φsΛ.fstFieldOfContract a]) (φs[φsΛ.sndFieldOfContract a])
∧ timeOrderRel (φs[φsΛ.sndFieldOfContract a]) (φs[φsΛ.fstFieldOfContract a]) := by
@ -92,7 +92,7 @@ lemma eqTimeOnly_iff_forall_finset {φs : List 𝓕.States} (φsΛ : WickContrac
simp_all
@[simp]
lemma empty_mem {φs : List 𝓕.States} : empty (n := φs.length).EqTimeOnly := by
lemma empty_mem {φs : List 𝓕.FieldOp} : empty (n := φs.length).EqTimeOnly := by
rw [eqTimeOnly_iff_forall_finset]
simp [empty]
@ -109,12 +109,12 @@ lemma staticContract_eq_timeContract_of_eqTimeOnly (h : φsΛ.EqTimeOnly) :
exact a.2
exact h
lemma eqTimeOnly_congr {φs φs' : List 𝓕.States} (h : φs = φs') (φsΛ : WickContraction φs.length) :
lemma eqTimeOnly_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs') (φsΛ : WickContraction φs.length) :
(congr (by simp [h]) φsΛ).EqTimeOnly (φs := φs') ↔ φsΛ.EqTimeOnly := by
subst h
simp
lemma quotContraction_eqTimeOnly {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma quotContraction_eqTimeOnly {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(h : φsΛ.EqTimeOnly) (S : Finset (Finset (Fin φs.length))) (ha : S ⊆ φsΛ.1) :
(φsΛ.quotContraction S ha).EqTimeOnly := by
rw [eqTimeOnly_iff_forall_finset]
@ -127,7 +127,7 @@ lemma quotContraction_eqTimeOnly {φs : List 𝓕.States} {φsΛ : WickContracti
rw [eqTimeOnly_iff_forall_finset] at h
apply h
lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(h : 0 < φsΛ.1.card) (h1 : φsΛ.EqTimeOnly) :
∃ (i j : Fin φs.length) (h : i < j) (φsucΛ : WickContraction [singleton h]ᵘᶜ.length),
φsΛ = join (singleton h) φsucΛ ∧ (timeOrderRel φs[i] φs[j] ∧ timeOrderRel φs[j] φs[i])
@ -161,7 +161,7 @@ lemma exists_join_singleton_of_card_ge_zero {φs : List 𝓕.States} (φsΛ : Wi
simp only [subContraction, Finset.card_singleton, id_eq, eq_mpr_eq_cast] at h1
omega
lemma timeOrder_timeContract_mul_of_eqTimeOnly_mid_induction {φs : List 𝓕.States}
lemma timeOrder_timeContract_mul_of_eqTimeOnly_mid_induction {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(hl : φsΛ.EqTimeOnly) (a b: 𝓕.FieldOpAlgebra) : (n : ℕ) → (hn : φsΛ.1.card = n) →
𝓣(a * φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(a * b)
@ -184,13 +184,13 @@ lemma timeOrder_timeContract_mul_of_eqTimeOnly_mid_induction {φs : List 𝓕.St
simp_all only [Nat.succ_eq_add_one, Fin.getElem_fin, add_left_inj]
simp_all
lemma timeOrder_timeContract_mul_of_eqTimeOnly_mid {φs : List 𝓕.States}
lemma timeOrder_timeContract_mul_of_eqTimeOnly_mid {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(hl : φsΛ.EqTimeOnly) (a b : 𝓕.FieldOpAlgebra) :
𝓣(a * φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(a * b) := by
exact timeOrder_timeContract_mul_of_eqTimeOnly_mid_induction φsΛ hl a b φsΛ.1.card rfl
lemma timeOrder_timeContract_mul_of_eqTimeOnly_left {φs : List 𝓕.States}
lemma timeOrder_timeContract_mul_of_eqTimeOnly_left {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(hl : φsΛ.EqTimeOnly) (b : 𝓕.FieldOpAlgebra) :
𝓣(φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(b) := by
@ -199,7 +199,7 @@ lemma timeOrder_timeContract_mul_of_eqTimeOnly_left {φs : List 𝓕.States}
rw [timeOrder_timeContract_mul_of_eqTimeOnly_mid φsΛ hl]
simp
lemma exists_join_singleton_of_not_eqTimeOnly {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma exists_join_singleton_of_not_eqTimeOnly {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(h1 : ¬ φsΛ.EqTimeOnly) :
∃ (i j : Fin φs.length) (h : i < j) (φsucΛ : WickContraction [singleton h]ᵘᶜ.length),
φsΛ = join (singleton h) φsucΛ ∧ (¬ timeOrderRel φs[i] φs[j] ∨ ¬ timeOrderRel φs[j] φs[i]) := by
@ -224,7 +224,7 @@ lemma exists_join_singleton_of_not_eqTimeOnly {φs : List 𝓕.States} (φsΛ :
· simp_all [h1]
· simp_all [h1]
lemma timeOrder_timeContract_of_not_eqTimeOnly {φs : List 𝓕.States}
lemma timeOrder_timeContract_of_not_eqTimeOnly {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length)
(hl : ¬ φsΛ.EqTimeOnly) : 𝓣(φsΛ.timeContract.1) = 0 := by
obtain ⟨i, j, hij, φsucΛ, rfl, hr⟩ := exists_join_singleton_of_not_eqTimeOnly φsΛ hl
@ -238,7 +238,7 @@ lemma timeOrder_timeContract_of_not_eqTimeOnly {φs : List 𝓕.States}
intro h
simp_all
lemma timeOrder_staticContract_of_not_mem {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma timeOrder_staticContract_of_not_mem {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(hl : ¬ φsΛ.EqTimeOnly) : 𝓣(φsΛ.staticContract.1) = 0 := by
obtain ⟨i, j, hij, φsucΛ, rfl, hr⟩ := exists_join_singleton_of_not_eqTimeOnly φsΛ hl
rw [join_staticContract]
@ -254,17 +254,17 @@ end EqTimeOnly
/-- The condition on a Wick contraction which is true if it has at least one contraction
which is between two equal time fields. -/
def HaveEqTime {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) : Prop :=
def HaveEqTime {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : Prop :=
∃ (i j : Fin φs.length) (h : {i, j} ∈ φsΛ.1),
timeOrderRel φs[i] φs[j] ∧ timeOrderRel φs[j] φs[i]
noncomputable instance {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
noncomputable instance {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
Decidable (HaveEqTime φsΛ) :=
inferInstanceAs (Decidable (∃ (i j : Fin φs.length)
(h : ({i, j} : Finset (Fin φs.length)) ∈ φsΛ.1),
timeOrderRel φs[i] φs[j] ∧ timeOrderRel φs[j] φs[i]))
lemma haveEqTime_iff_finset {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
lemma haveEqTime_iff_finset {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
HaveEqTime φsΛ ↔ ∃ (a : Finset (Fin φs.length)) (h : a ∈ φsΛ.1),
timeOrderRel φs[φsΛ.fstFieldOfContract ⟨a, h⟩] φs[φsΛ.sndFieldOfContract ⟨a, h⟩]
∧ timeOrderRel φs[φsΛ.sndFieldOfContract ⟨a, h⟩] φs[φsΛ.fstFieldOfContract ⟨a, h⟩] := by
@ -297,20 +297,20 @@ lemma haveEqTime_iff_finset {φs : List 𝓕.States} (φsΛ : WickContraction φ
exact h1
@[simp]
lemma empty_not_haveEqTime {φs : List 𝓕.States} :
lemma empty_not_haveEqTime {φs : List 𝓕.FieldOp} :
¬ HaveEqTime (empty : WickContraction φs.length) := by
rw [haveEqTime_iff_finset]
simp [empty]
/-- Given a Wick contraction the subset of contracted pairs between eqaul time fields. -/
def eqTimeContractSet {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
def eqTimeContractSet {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
Finset (Finset (Fin φs.length)) :=
Finset.univ.filter (fun a =>
a ∈ φsΛ.1 ∧ ∀ (h : a ∈ φsΛ.1),
timeOrderRel φs[φsΛ.fstFieldOfContract ⟨a, h⟩] φs[φsΛ.sndFieldOfContract ⟨a, h⟩]
∧ timeOrderRel φs[φsΛ.sndFieldOfContract ⟨a, h⟩] φs[φsΛ.fstFieldOfContract ⟨a, h⟩])
lemma eqTimeContractSet_subset {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
lemma eqTimeContractSet_subset {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
eqTimeContractSet φsΛ ⊆ φsΛ.1 := by
simp only [eqTimeContractSet, Fin.getElem_fin]
intro a
@ -318,12 +318,12 @@ lemma eqTimeContractSet_subset {φs : List 𝓕.States} (φsΛ : WickContraction
intro h _
exact h
lemma mem_of_mem_eqTimeContractSet{φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma mem_of_mem_eqTimeContractSet{φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{a : Finset (Fin φs.length)} (h : a ∈ eqTimeContractSet φsΛ) : a ∈ φsΛ.1 := by
simp only [eqTimeContractSet, Fin.getElem_fin, Finset.mem_filter, Finset.mem_univ, true_and] at h
exact h.1
lemma join_eqTimeContractSet {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_eqTimeContractSet {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
eqTimeContractSet (join φsΛ φsucΛ) = φsΛ.eqTimeContractSet ∪
φsucΛ.eqTimeContractSet.map (Finset.mapEmbedding uncontractedListEmd).toEmbedding := by
@ -378,7 +378,7 @@ lemma join_eqTimeContractSet {φs : List 𝓕.States} (φsΛ : WickContraction
join_sndFieldOfContract_joinLiftRight]
simpa using h2
lemma eqTimeContractSet_of_not_haveEqTime {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma eqTimeContractSet_of_not_haveEqTime {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(h : ¬ HaveEqTime φsΛ) : eqTimeContractSet φsΛ = ∅ := by
ext a
simp only [Finset.not_mem_empty, iff_false]
@ -389,7 +389,7 @@ lemma eqTimeContractSet_of_not_haveEqTime {φs : List 𝓕.States} {φsΛ : Wick
have h2 := hn.2 hn.1
simp_all
lemma eqTimeContractSet_of_mem_eqTimeOnly {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma eqTimeContractSet_of_mem_eqTimeOnly {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(h : φsΛ.EqTimeOnly) : eqTimeContractSet φsΛ = φsΛ.1 := by
ext a
simp only [eqTimeContractSet, Fin.getElem_fin, Finset.mem_filter, Finset.mem_univ, true_and,
@ -397,7 +397,7 @@ lemma eqTimeContractSet_of_mem_eqTimeOnly {φs : List 𝓕.States} {φsΛ : Wick
rw [EqTimeOnly.eqTimeOnly_iff_forall_finset] at h
exact fun h_1 => h ⟨a, h_1⟩
lemma subContraction_eqTimeContractSet_eqTimeOnly {φs : List 𝓕.States}
lemma subContraction_eqTimeContractSet_eqTimeOnly {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) :
(φsΛ.subContraction (eqTimeContractSet φsΛ) (eqTimeContractSet_subset φsΛ)).EqTimeOnly := by
rw [EqTimeOnly.eqTimeOnly_iff_forall_finset]
@ -408,7 +408,7 @@ lemma subContraction_eqTimeContractSet_eqTimeOnly {φs : List 𝓕.States}
simp only [subContraction_fstFieldOfContract, Fin.getElem_fin, subContraction_sndFieldOfContract]
exact ha2.2 ha2.1
lemma pair_mem_eqTimeContractSet_iff {φs : List 𝓕.States} {i j : Fin φs.length}
lemma pair_mem_eqTimeContractSet_iff {φs : List 𝓕.FieldOp} {i j : Fin φs.length}
(φsΛ : WickContraction φs.length) (h : {i, j} ∈ φsΛ.1) :
{i, j} ∈ φsΛ.eqTimeContractSet ↔ timeOrderRel φs[i] φs[j] ∧ timeOrderRel φs[j] φs[i] := by
simp only [eqTimeContractSet, Fin.getElem_fin, Finset.mem_filter, Finset.mem_univ, true_and]
@ -434,7 +434,7 @@ lemma pair_mem_eqTimeContractSet_iff {φs : List 𝓕.States} {i j : Fin φs.len
simp_all only [and_self]
lemma subContraction_eqTimeContractSet_not_empty_of_haveEqTime
{φs : List 𝓕.States} (φsΛ : WickContraction φs.length) (h : HaveEqTime φsΛ) :
{φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (h : HaveEqTime φsΛ) :
φsΛ.subContraction (eqTimeContractSet φsΛ) (eqTimeContractSet_subset φsΛ) ≠ empty := by
simp only [ne_eq]
erw [Subtype.eq_iff]
@ -448,7 +448,7 @@ lemma subContraction_eqTimeContractSet_not_empty_of_haveEqTime
simp_all only [Fin.getElem_fin, and_self]
exact h1
lemma quotContraction_eqTimeContractSet_not_haveEqTime {φs : List 𝓕.States}
lemma quotContraction_eqTimeContractSet_not_haveEqTime {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) :
¬ HaveEqTime (φsΛ.quotContraction (eqTimeContractSet φsΛ) (eqTimeContractSet_subset φsΛ)) := by
rw [haveEqTime_iff_finset]
@ -468,7 +468,7 @@ lemma quotContraction_eqTimeContractSet_not_haveEqTime {φs : List 𝓕.States}
obtain ⟨h, h1⟩ := hn''
simp_all
lemma join_haveEqTime_of_eqTimeOnly_nonEmpty {φs : List 𝓕.States} (φsΛ : WickContraction φs.length)
lemma join_haveEqTime_of_eqTimeOnly_nonEmpty {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length)
(h1 : φsΛ.EqTimeOnly) (h2 : φsΛ ≠ empty)
(φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) :
HaveEqTime (join φsΛ φsucΛ) := by
@ -483,7 +483,7 @@ lemma join_haveEqTime_of_eqTimeOnly_nonEmpty {φs : List 𝓕.States} (φsΛ : W
rw [Finset.pair_comm]
exact h
lemma hasEqTimeEquiv_ext_sigma {φs : List 𝓕.States} {x1 x2 :
lemma hasEqTimeEquiv_ext_sigma {φs : List 𝓕.FieldOp} {x1 x2 :
Σ (φsΛ : {φsΛ : WickContraction φs.length // φsΛ.EqTimeOnly ∧ φsΛ ≠ empty}),
{φssucΛ : WickContraction [φsΛ.1]ᵘᶜ.length // ¬ HaveEqTime φssucΛ}}
(h1 : x1.1.1 = x2.1.1) (h2 : x1.2.1 = congr (by simp [h1]) x2.2.1) : x1 = x2 := by
@ -497,7 +497,7 @@ lemma hasEqTimeEquiv_ext_sigma {φs : List 𝓕.States} {x1 x2 :
/-- The equivalence which seperates a Wick contraction which has an equal time contraction
into a non-empty contraction only between equal-time fields and a Wick contraction which
does not have equal time contractions. -/
def hasEqTimeEquiv (φs : List 𝓕.States) :
def hasEqTimeEquiv (φs : List 𝓕.FieldOp) :
{φsΛ : WickContraction φs.length // HaveEqTime φsΛ} ≃
Σ (φsΛ : {φsΛ : WickContraction φs.length // φsΛ.EqTimeOnly ∧ φsΛ ≠ empty}),
{φssucΛ : WickContraction [φsΛ.1]ᵘᶜ.length // ¬ HaveEqTime φssucΛ} where
@ -538,7 +538,7 @@ def hasEqTimeEquiv (φs : List 𝓕.States) :
rw [uncontractedListEmd_congr hs]
rw [Finset.map_map]
lemma sum_haveEqTime (φs : List 𝓕.States)
lemma sum_haveEqTime (φs : List 𝓕.FieldOp)
(f : WickContraction φs.length → M) [AddCommMonoid M]:
∑ (φsΛ : {φsΛ : WickContraction φs.length // HaveEqTime φsΛ}), f φsΛ =
∑ (φsΛ : {φsΛ : WickContraction φs.length // φsΛ.EqTimeOnly ∧ φsΛ ≠ empty}),

22
HepLean/PerturbationTheory/WickContraction/TimeContract.lean
View file

@ -21,7 +21,7 @@ open FieldOpAlgebra
/-- Given a Wick contraction `φsΛ` associated with a list `φs`, the
product of all time-contractions of pairs of contracted elements in `φs`,
as a member of the center of `𝓞.A`. -/
noncomputable def timeContract {φs : List 𝓕.States}
noncomputable def timeContract {φs : List 𝓕.FieldOp}
(φsΛ : WickContraction φs.length) :
Subalgebra.center ℂ 𝓕.FieldOpAlgebra :=
∏ (a : φsΛ.1), ⟨FieldOpAlgebra.timeContract
@ -35,7 +35,7 @@ This result follows from the fact that `timeContract` only depends on contracted
and `(φsΛ ↩Λ φ i none)` has the 'same' contracted pairs as `φsΛ`. -/
@[simp]
lemma timeContract_insertAndContract_none
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
(φsΛ ↩Λ φ i none).timeContract = φsΛ.timeContract := by
rw [timeContract, insertAndContract_none_prod_contractions]
@ -52,7 +52,7 @@ This follows from the fact that `(φsΛ ↩Λ φ i (some j))` has one more contr
corresponding to `φ` contracted with `φⱼ`. The order depends on whether we insert `φ` before
or after `φⱼ`. -/
lemma timeConract_insertAndContract_some
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).timeContract =
(if i < i.succAbove j then
@ -71,7 +71,7 @@ lemma timeConract_insertAndContract_some
simp
@[simp]
lemma timeContract_empty (φs : List 𝓕.States) :
lemma timeContract_empty (φs : List 𝓕.FieldOp) :
(@empty φs.length).timeContract = 1 := by
rw [timeContract, empty]
simp
@ -79,16 +79,16 @@ lemma timeContract_empty (φs : List 𝓕.States) :
open FieldStatistic
lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
(ht : 𝓕.timeOrderRel φ φs[k.1]) (hik : i < i.succAbove k) :
(φsΛ ↩Λ φ i (some k)).timeContract =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < k))⟩)
• (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedStatesEquiv φs φsΛ) (some k)) *
• (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) *
φsΛ.timeContract) := by
rw [timeConract_insertAndContract_some]
simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1,
contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
contractStateAtIndex, uncontractedFieldOpEquiv, 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, uncontractedListGet]
@ -112,16 +112,16 @@ lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
· exact ht
lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_not_lt
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted)
(ht : ¬ 𝓕.timeOrderRel φs[k.1] φ) (hik : ¬ i < i.succAbove k) :
(φsΛ ↩Λ φ i (some k)).timeContract =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x ≤ k))⟩)
• (contractStateAtIndex φ [φsΛ]ᵘᶜ
((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract) := by
((uncontractedFieldOpEquiv φs φsΛ) (some k)) * φsΛ.timeContract) := by
rw [timeConract_insertAndContract_some]
simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1,
contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
contractStateAtIndex, uncontractedFieldOpEquiv, 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, uncontractedListGet]
@ -163,7 +163,7 @@ lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_not_lt
simp_all only [Fin.getElem_fin, Nat.succ_eq_add_one, not_lt, false_or]
exact ht
lemma timeContract_of_not_gradingCompliant (φs : List 𝓕.States)
lemma timeContract_of_not_gradingCompliant (φs : List 𝓕.FieldOp)
(φsΛ : WickContraction φs.length) (h : ¬ GradingCompliant φs φsΛ) :
φsΛ.timeContract = 0 := by
rw [timeContract]

42
HepLean/PerturbationTheory/WickContraction/UncontractedList.lean
View file

@ -316,41 +316,41 @@ lemma take_uncontractedIndexEquiv_symm (k : c.uncontracted) :
/-- Given a Wick Contraction `φsΛ` for a list of states `φs`. The list of uncontracted
states in `φs`. -/
def uncontractedListGet {φs : List 𝓕.States} (φsΛ : WickContraction φs.length) :
List 𝓕.States := φsΛ.uncontractedList.map φs.get
def uncontractedListGet {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) :
List 𝓕.FieldOp := φsΛ.uncontractedList.map φs.get
@[inherit_doc uncontractedListGet]
scoped[WickContraction] notation "[" φsΛ "]ᵘᶜ" => uncontractedListGet φsΛ
@[simp]
lemma uncontractedListGet_empty {φs : List 𝓕.States} :
lemma uncontractedListGet_empty {φs : List 𝓕.FieldOp} :
(empty (n := φs.length)).uncontractedListGet = φs := by
simp [uncontractedListGet]
/-!
## uncontractedStatesEquiv
## uncontractedFieldOpEquiv
-/
/-- 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) (φsΛ : WickContraction φs.length) :
def uncontractedFieldOpEquiv (φs : List 𝓕.FieldOp) (φ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) (φsΛ : WickContraction φs.length) :
(uncontractedStatesEquiv φs φsΛ).toFun none = none := by
simp [uncontractedStatesEquiv]
lemma uncontractedFieldOpEquiv_none (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) :
(uncontractedFieldOpEquiv φs φsΛ).toFun none = none := by
simp [uncontractedFieldOpEquiv]
lemma uncontractedStatesEquiv_list_sum [AddCommMonoid α] (φs : List 𝓕.States)
lemma uncontractedFieldOpEquiv_list_sum [AddCommMonoid α] (φs : List 𝓕.FieldOp)
(φ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]
∑ (i : Option φsΛ.uncontracted), f (φsΛ.uncontractedFieldOpEquiv φs i) := by
rw [(φsΛ.uncontractedFieldOpEquiv φs).sum_comp]
/-!
@ -359,34 +359,34 @@ lemma uncontractedStatesEquiv_list_sum [AddCommMonoid α] (φs : List 𝓕.State
-/
/-- The embedding of `Fin [φsΛ]ᵘᶜ.length` into `Fin φs.length`. -/
def uncontractedListEmd {φs : List 𝓕.States} {φsΛ : WickContraction φs.length} :
def uncontractedListEmd {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length} :
Fin [φsΛ]ᵘᶜ.length ↪ Fin φs.length := ((finCongr (by simp [uncontractedListGet])).trans
φsΛ.uncontractedIndexEquiv).toEmbedding.trans
(Function.Embedding.subtype fun x => x ∈ φsΛ.uncontracted)
lemma uncontractedListEmd_congr {φs : List 𝓕.States} {φsΛ φsΛ' : WickContraction φs.length}
lemma uncontractedListEmd_congr {φs : List 𝓕.FieldOp} {φsΛ φsΛ' : WickContraction φs.length}
(h : φsΛ = φsΛ') : φsΛ.uncontractedListEmd =
(finCongr (by simp [h])).toEmbedding.trans φsΛ'.uncontractedListEmd := by
subst h
rfl
lemma uncontractedListEmd_toFun_eq_get (φs : List 𝓕.States) (φsΛ : WickContraction φs.length) :
lemma uncontractedListEmd_toFun_eq_get (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) :
(uncontractedListEmd (φsΛ := φsΛ)).toFun =
φsΛ.uncontractedList.get ∘ (finCongr (by simp [uncontractedListGet])) := by
rfl
lemma uncontractedListEmd_strictMono {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma uncontractedListEmd_strictMono {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
{i j : Fin [φsΛ]ᵘᶜ.length} (h : i < j) : uncontractedListEmd i < uncontractedListEmd j := by
simp only [uncontractedListEmd, uncontractedIndexEquiv, List.get_eq_getElem,
Equiv.trans_toEmbedding, Function.Embedding.trans_apply, Equiv.coe_toEmbedding, finCongr_apply,
Equiv.coe_fn_mk, Fin.coe_cast, Function.Embedding.coe_subtype]
exact List.Sorted.get_strictMono φsΛ.uncontractedList_sorted_lt h
lemma uncontractedListEmd_mem_uncontracted {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma uncontractedListEmd_mem_uncontracted {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(i : Fin [φsΛ]ᵘᶜ.length) : uncontractedListEmd i ∈ φsΛ.uncontracted := by
simp [uncontractedListEmd]
lemma uncontractedListEmd_surjective_mem_uncontracted {φs : List 𝓕.States}
lemma uncontractedListEmd_surjective_mem_uncontracted {φs : List 𝓕.FieldOp}
{φsΛ : WickContraction φs.length} (i : Fin φs.length) (hi : i ∈ φsΛ.uncontracted) :
∃ j, φsΛ.uncontractedListEmd j = i := by
simp only [uncontractedListEmd, Equiv.trans_toEmbedding, Function.Embedding.trans_apply,
@ -401,7 +401,7 @@ lemma uncontractedListEmd_surjective_mem_uncontracted {φs : List 𝓕.States}
rw [hj]
@[simp]
lemma uncontractedListEmd_finset_disjoint_left {φs : List 𝓕.States}
lemma uncontractedListEmd_finset_disjoint_left {φs : List 𝓕.FieldOp}
{φsΛ : WickContraction φs.length} (a : Finset (Fin [φsΛ]ᵘᶜ.length))
(b : Finset (Fin φs.length)) (hb : b ∈ φsΛ.1) : Disjoint (a.map uncontractedListEmd) b := by
rw [Finset.disjoint_left]
@ -413,7 +413,7 @@ lemma uncontractedListEmd_finset_disjoint_left {φs : List 𝓕.States}
rw [mem_uncontracted_iff_not_contracted] at h1
exact h1 b hb
lemma uncontractedListEmd_finset_not_mem {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma uncontractedListEmd_finset_not_mem {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(a : Finset (Fin [φsΛ]ᵘᶜ.length)) :
a.map uncontractedListEmd ∉ φsΛ.1 := by
by_contra hn
@ -424,13 +424,13 @@ lemma uncontractedListEmd_finset_not_mem {φs : List 𝓕.States} {φsΛ : WickC
simp at h2
@[simp]
lemma getElem_uncontractedListEmd {φs : List 𝓕.States} {φsΛ : WickContraction φs.length}
lemma getElem_uncontractedListEmd {φs : List 𝓕.FieldOp} {φsΛ : WickContraction φs.length}
(k : Fin [φsΛ]ᵘᶜ.length) : φs[(uncontractedListEmd k).1] = [φsΛ]ᵘᶜ[k.1] := by
simp only [uncontractedListGet, List.getElem_map, List.get_eq_getElem]
rfl
@[simp]
lemma uncontractedListEmd_empty {φs : List 𝓕.States} :
lemma uncontractedListEmd_empty {φs : List 𝓕.FieldOp} :
(empty (n := φs.length)).uncontractedListEmd = (finCongr (by simp)).toEmbedding := by
ext x
simp [uncontractedListEmd, uncontractedIndexEquiv]

30
HepLean/PerturbationTheory/WicksTheorem.lean
View file

@ -37,7 +37,7 @@ Let `c` be a Wick Contraction for `φs := φ₀φ₁…φₙ`.
We have (roughly) `𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ) = s • 𝓝ᶠ(φ :: [φsΛ]ᵘᶜ)`
Where `s` is the exchange sign for `φ` and the uncontracted fields in `φ₀φ₁…φᵢ₋₁`.
-/
lemma normalOrder_uncontracted_none (φ : 𝓕.States) (φs : List 𝓕.States)
lemma normalOrder_uncontracted_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ)
= 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => i.succAbove x < i)⟩) •
@ -107,11 +107,11 @@ We have (roughly) `N(c ↩Λ φ i k).uncontractedList`
is equal to `N((c.uncontractedList).eraseIdx k')`
where `k'` is the position in `c.uncontractedList` corresponding to `k`.
-/
lemma normalOrder_uncontracted_some (φ : 𝓕.States) (φs : List 𝓕.States)
lemma normalOrder_uncontracted_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) :
𝓝(ofFieldOpList [φsΛ ↩Λ φ i (some k)]ᵘᶜ)
= 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedStatesEquiv φs φsΛ) k))) := by
simp only [Nat.succ_eq_add_one, insertAndContract, optionEraseZ, uncontractedStatesEquiv,
= 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedFieldOpEquiv φs φsΛ) k))) := by
simp only [Nat.succ_eq_add_one, insertAndContract, optionEraseZ, uncontractedFieldOpEquiv,
Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply,
Fin.coe_cast, uncontractedListGet]
congr
@ -152,7 +152,7 @@ The proof of this result relies primarily on:
- `sign_insert_none` and `signInsertNone_eq_filterset` which are used to take account of
signs.
-/
lemma wick_term_none_eq_wick_term_cons (φ : 𝓕.States) (φs : List 𝓕.States)
lemma wick_term_none_eq_wick_term_cons (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
(φsΛ ↩Λ φ i none).sign • (φsΛ ↩Λ φ i none).timeContract
* 𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ) =
@ -200,7 +200,7 @@ This lemma states that
for `c` equal to `c ↩Λ φ i (some k)` is equal to that for just `c`
mulitiplied by the exchange sign of `φ` and `φ₀φ₁…φᵢ₋₁`.
-/
lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List 𝓕.States)
lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp)
(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] φ) :
@ -208,8 +208,8 @@ lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List
* 𝓝(ofFieldOpList [φsΛ ↩Λ φ i (some k)]ᵘᶜ) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩)
• (φsΛ.sign • (contractStateAtIndex φ [φsΛ]ᵘᶜ
((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract)
* 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedStatesEquiv φs φsΛ k)))) := by
((uncontractedFieldOpEquiv φs φsΛ) (some k)) * φsΛ.timeContract)
* 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedFieldOpEquiv φs φsΛ k)))) := by
by_cases hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[k.1])
· by_cases hk : i.succAbove k < i
· rw [WickContraction.timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_not_lt]
@ -239,7 +239,7 @@ lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List
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,
instCommGroup.eq_1, contractStateAtIndex, uncontractedFieldOpEquiv, 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,
uncontractedListGet]
@ -276,7 +276,7 @@ The proof of this result primarily depends on
- `wick_term_none_eq_wick_term_cons`
- `wick_term_some_eq_wick_term_optionEraseZ`
-/
lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.States) (φs : List 𝓕.States) (i : Fin φs.length.succ)
lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ)
(φsΛ : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k])
(hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬timeOrderRel φs[k] φ) :
(φsΛ.sign • φsΛ.timeContract) * ((ofFieldOp φ) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)) =
@ -284,14 +284,14 @@ lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.States) (φs : List 𝓕.States
∑ (k : Option φsΛ.uncontracted), ((φsΛ ↩Λ φ i k).sign •
(φsΛ ↩Λ φ i k).timeContract * (𝓝(ofFieldOpList [φsΛ ↩Λ φ i k]ᵘᶜ))) := by
rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum, Finset.mul_sum,
uncontractedStatesEquiv_list_sum, Finset.smul_sum]
uncontractedFieldOpEquiv_list_sum, Finset.smul_sum]
simp only [instCommGroup.eq_1, Nat.succ_eq_add_one]
congr 1
funext n
match n with
| none =>
rw [wick_term_none_eq_wick_term_cons]
simp only [contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply,
Equiv.coe_trans, Option.map_none', one_mul, Algebra.smul_mul_assoc, instCommGroup.eq_1,
smul_smul]
congr 1
@ -300,7 +300,7 @@ lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.States) (φs : List 𝓕.States
| some n =>
rw [wick_term_some_eq_wick_term_optionEraseZ _ _ _ _ _
(fun k => hlt k) (fun k a => hn k a)]
simp only [uncontractedStatesEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some',
simp only [uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some',
Function.comp_apply, finCongr_apply, Algebra.smul_mul_assoc, instCommGroup.eq_1, smul_smul]
congr 1
· rw [← mul_assoc, exchangeSign_mul_self]
@ -334,7 +334,7 @@ lemma wicks_theorem_nil :
OneMemClass.coe_one, normalOrderSign_nil, normalOrderList_nil, one_smul, one_mul]
rfl
lemma wicks_theorem_congr {φs φs' : List 𝓕.States} (h : φs = φs') :
lemma wicks_theorem_congr {φs φs' : List 𝓕.FieldOp} (h : φs = φs') :
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)
= ∑ (φs'Λ : WickContraction φs'.length), (φs'Λ.sign • φs'Λ.timeContract) *
𝓝(ofFieldOpList [φs'Λ]ᵘᶜ) := by
@ -357,7 +357,7 @@ remark wicks_theorem_context := "
- The product of time-contractions of the contracted pairs of `c`.
- The normal-ordering of the uncontracted fields in `c`.
-/
theorem wicks_theorem : (φs : List 𝓕.States) → 𝓣(ofFieldOpList φs) =
theorem wicks_theorem : (φs : List 𝓕.FieldOp) → 𝓣(ofFieldOpList φs) =
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)
| [] => wicks_theorem_nil
| φ :: φs => by