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

Merge pull request #304 from HEPLean/FieldOpAlgebra

Browse source 
feat: Wick's theorem for FieldOpAlgebra
This commit is contained in:
Joseph Tooby-Smith 2025-01-30 11:32:40 +00:00 • committed by GitHub
commit b7fa5cecaf
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 1643 additions and 1378 deletions
Download patch file Download diff file Expand all files Collapse all files

4
HepLean.lean
View file

@ -130,10 +130,8 @@ import HepLean.PerturbationTheory.Algebras.CrAnAlgebra.TimeOrder
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.Basic
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.SuperCommute
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.TimeContraction
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.TimeOrder
import HepLean.PerturbationTheory.Algebras.ProtoOperatorAlgebra.Basic
import HepLean.PerturbationTheory.Algebras.ProtoOperatorAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.ProtoOperatorAlgebra.TimeContraction
import HepLean.PerturbationTheory.CreateAnnihilate
import HepLean.PerturbationTheory.FeynmanDiagrams.Basic
import HepLean.PerturbationTheory.FeynmanDiagrams.Instances.ComplexScalar

50
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/Basic.lean
View file

@ -22,9 +22,9 @@ The main structures defined in this module are:
* `ofCrAnState` - Maps a creation/annihilation state to the algebra
* `ofCrAnList` - Maps a list of creation/annihilation states to the algebra
* `ofState` - Maps a state to a sum of creation and annihilation operators
* `crPart` - The creation part of a state in the algebra
* `anPart` - The annihilation part of a state in the algebra
* `superCommute` - The super commutator on the algebra
* `crPartF` - The creation part of a state in the algebra
* `anPartF` - The annihilation part of a state in the algebra
* `superCommuteF` - The super commutator on the algebra
The key lemmas show how these operators interact, particularly focusing on the
super commutation relations between creation and annihilation operators.
@ -113,55 +113,55 @@ lemma ofStateList_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 crPart : 𝓕.States → 𝓕.CrAnAlgebra := fun φ =>
def crPartF : 𝓕.States → 𝓕.CrAnAlgebra := fun φ =>
match φ with
| States.inAsymp φ => ofCrAnState ⟨States.inAsymp φ, ()⟩
| States.position φ => ofCrAnState ⟨States.position φ, CreateAnnihilate.create⟩
| States.outAsymp _ => 0
@[simp]
lemma crPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPart (States.inAsymp φ) = ofCrAnState ⟨States.inAsymp φ, ()⟩ := by
simp [crPart]
lemma crPartF_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPartF (States.inAsymp φ) = ofCrAnState ⟨States.inAsymp φ, ()⟩ := by
simp [crPartF]
@[simp]
lemma crPart_position (φ : 𝓕.PositionStates) :
crPart (States.position φ) =
lemma crPartF_position (φ : 𝓕.PositionStates) :
crPartF (States.position φ) =
ofCrAnState ⟨States.position φ, CreateAnnihilate.create⟩ := by
simp [crPart]
simp [crPartF]
@[simp]
lemma crPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPart (States.outAsymp φ) = 0 := by
simp [crPart]
lemma crPartF_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPartF (States.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 anPart : 𝓕.States → 𝓕.CrAnAlgebra := fun φ =>
def anPartF : 𝓕.States → 𝓕.CrAnAlgebra := fun φ =>
match φ with
| States.inAsymp _ => 0
| States.position φ => ofCrAnState ⟨States.position φ, CreateAnnihilate.annihilate⟩
| States.outAsymp φ => ofCrAnState ⟨States.outAsymp φ, ()⟩
@[simp]
lemma anPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPart (States.inAsymp φ) = 0 := by
simp [anPart]
lemma anPartF_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPartF (States.inAsymp φ) = 0 := by
simp [anPartF]
@[simp]
lemma anPart_position (φ : 𝓕.PositionStates) :
anPart (States.position φ) =
lemma anPartF_position (φ : 𝓕.PositionStates) :
anPartF (States.position φ) =
ofCrAnState ⟨States.position φ, CreateAnnihilate.annihilate⟩ := by
simp [anPart]
simp [anPartF]
@[simp]
lemma anPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPart (States.outAsymp φ) = ofCrAnState ⟨States.outAsymp φ, ()⟩ := by
simp [anPart]
lemma anPartF_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPartF (States.outAsymp φ) = ofCrAnState ⟨States.outAsymp φ, ()⟩ := by
simp [anPartF]
lemma ofState_eq_crPart_add_anPart (φ : 𝓕.States) :
ofState φ = crPart φ + anPart φ := by
lemma ofState_eq_crPartF_add_anPartF (φ : 𝓕.States) :
ofState φ = crPartF φ + anPartF φ := by
rw [ofState]
cases φ with
| inAsymp φ => simp [statesToCrAnType]

303
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/NormalOrder.lean
View file

@ -32,24 +32,24 @@ noncomputable section
a list of CrAnStates to the normal-ordered list of states multiplied by
the sign corresponding to the number of fermionic-fermionic
exchanges done in ordering. -/
def normalOrder : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 :=
def normalOrderF : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 :=
Basis.constr ofCrAnListBasis ℂ fun φs =>
normalOrderSign φs • ofCrAnList (normalOrderList φs)
@[inherit_doc normalOrder]
scoped[FieldSpecification.CrAnAlgebra] notation "𝓝ᶠ(" a ")" => normalOrder a
@[inherit_doc normalOrderF]
scoped[FieldSpecification.CrAnAlgebra] notation "𝓝ᶠ(" a ")" => normalOrderF a
lemma normalOrder_ofCrAnList (φs : List 𝓕.CrAnStates) :
lemma normalOrderF_ofCrAnList (φs : List 𝓕.CrAnStates) :
𝓝ᶠ(ofCrAnList φs) = normalOrderSign φs • ofCrAnList (normalOrderList φs) := by
rw [← ofListBasis_eq_ofList, normalOrder, Basis.constr_basis]
rw [← ofListBasis_eq_ofList, normalOrderF, Basis.constr_basis]
lemma ofCrAnList_eq_normalOrder (φs : List 𝓕.CrAnStates) :
lemma ofCrAnList_eq_normalOrderF (φs : List 𝓕.CrAnStates) :
ofCrAnList (normalOrderList φs) = normalOrderSign φs • 𝓝ᶠ(ofCrAnList φs) := by
rw [normalOrder_ofCrAnList, normalOrderList, smul_smul, normalOrderSign, Wick.koszulSign_mul_self,
one_smul]
rw [normalOrderF_ofCrAnList, normalOrderList, smul_smul, normalOrderSign,
Wick.koszulSign_mul_self, one_smul]
lemma normalOrder_one : normalOrder (𝓕 := 𝓕) 1 = 1 := by
rw [← ofCrAnList_nil, normalOrder_ofCrAnList, normalOrderSign_nil, normalOrderList_nil,
lemma normalOrderF_one : normalOrderF (𝓕 := 𝓕) 1 = 1 := by
rw [← ofCrAnList_nil, normalOrderF_ofCrAnList, normalOrderSign_nil, normalOrderList_nil,
ofCrAnList_nil, one_smul]
/-!
@ -58,208 +58,209 @@ lemma normalOrder_one : normalOrder (𝓕 := 𝓕) 1 = 1 := by
-/
lemma normalOrder_ofCrAnList_cons_create (φ : 𝓕.CrAnStates)
lemma normalOrderF_ofCrAnList_cons_create (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (φs : List 𝓕.CrAnStates) :
𝓝ᶠ(ofCrAnList (φ :: φs)) = ofCrAnState φ * 𝓝ᶠ(ofCrAnList φs) := by
rw [normalOrder_ofCrAnList, normalOrderSign_cons_create φ hφ, normalOrderList_cons_create φ hφ φs]
rw [ofCrAnList_cons, normalOrder_ofCrAnList, mul_smul_comm]
rw [normalOrderF_ofCrAnList, normalOrderSign_cons_create φ hφ,
normalOrderList_cons_create φ hφ φs]
rw [ofCrAnList_cons, normalOrderF_ofCrAnList, mul_smul_comm]
lemma normalOrder_create_mul (φ : 𝓕.CrAnStates)
lemma normalOrderF_create_mul (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.create) (a : CrAnAlgebra 𝓕) :
𝓝ᶠ(ofCrAnState φ * a) = ofCrAnState φ * 𝓝ᶠ(a) := by
change (normalOrder ∘ₗ mulLinearMap (ofCrAnState φ)) a =
(mulLinearMap (ofCrAnState φ) ∘ₗ normalOrder) a
change (normalOrderF ∘ₗ mulLinearMap (ofCrAnState φ)) a =
(mulLinearMap (ofCrAnState φ) ∘ₗ normalOrderF) a
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply]
rw [← ofCrAnList_cons, normalOrder_ofCrAnList_cons_create φ hφ]
rw [← ofCrAnList_cons, normalOrderF_ofCrAnList_cons_create φ hφ]
lemma normalOrder_ofCrAnList_append_annihilate (φ : 𝓕.CrAnStates)
lemma normalOrderF_ofCrAnList_append_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate) (φs : List 𝓕.CrAnStates) :
𝓝ᶠ(ofCrAnList (φs ++ [φ])) = 𝓝ᶠ(ofCrAnList φs) * ofCrAnState φ := by
rw [normalOrder_ofCrAnList, normalOrderSign_append_annihlate φ hφ φs,
rw [normalOrderF_ofCrAnList, normalOrderSign_append_annihlate φ hφ φs,
normalOrderList_append_annihilate φ hφ φs, ofCrAnList_append, ofCrAnList_singleton,
normalOrder_ofCrAnList, smul_mul_assoc]
normalOrderF_ofCrAnList, smul_mul_assoc]
lemma normalOrder_mul_annihilate (φ : 𝓕.CrAnStates)
lemma normalOrderF_mul_annihilate (φ : 𝓕.CrAnStates)
(hφ : 𝓕 |>ᶜ φ = CreateAnnihilate.annihilate)
(a : CrAnAlgebra 𝓕) : 𝓝ᶠ(a * ofCrAnState φ) = 𝓝ᶠ(a) * ofCrAnState φ := by
change (normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φ)) a =
(mulLinearMap.flip (ofCrAnState φ) ∘ₗ normalOrder) a
change (normalOrderF ∘ₗ mulLinearMap.flip (ofCrAnState φ)) a =
(mulLinearMap.flip (ofCrAnState φ) ∘ₗ normalOrderF) a
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk]
rw [← ofCrAnList_singleton, ← ofCrAnList_append, ofCrAnList_singleton,
normalOrder_ofCrAnList_append_annihilate φ hφ]
normalOrderF_ofCrAnList_append_annihilate φ hφ]
lemma normalOrder_crPart_mul (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
𝓝ᶠ(crPart φ * a) =
crPart φ * 𝓝ᶠ(a) := by
lemma normalOrderF_crPartF_mul (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
𝓝ᶠ(crPartF φ * a) =
crPartF φ * 𝓝ᶠ(a) := by
match φ with
| .inAsymp φ =>
rw [crPart]
exact normalOrder_create_mul ⟨States.inAsymp φ, ()⟩ rfl a
rw [crPartF]
exact normalOrderF_create_mul ⟨States.inAsymp φ, ()⟩ rfl a
| .position φ =>
rw [crPart]
exact normalOrder_create_mul _ rfl _
rw [crPartF]
exact normalOrderF_create_mul _ rfl _
| .outAsymp φ => simp
lemma normalOrder_mul_anPart (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * anPart φ) =
𝓝ᶠ(a) * anPart φ := by
lemma normalOrderF_mul_anPartF (φ : 𝓕.States) (a : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * anPartF φ) =
𝓝ᶠ(a) * anPartF φ := by
match φ with
| .inAsymp φ => simp
| .position φ =>
rw [anPart]
exact normalOrder_mul_annihilate _ rfl _
rw [anPartF]
exact normalOrderF_mul_annihilate _ rfl _
| .outAsymp φ =>
rw [anPart]
refine normalOrder_mul_annihilate _ rfl _
rw [anPartF]
refine normalOrderF_mul_annihilate _ rfl _
/-!
## Normal ordering for an adjacent creation and annihliation state
The main result of this section is `normalOrder_superCommute_annihilate_create`.
The main result of this section is `normalOrderF_superCommuteF_annihilate_create`.
-/
lemma normalOrder_swap_create_annihlate_ofCrAnList_ofCrAnList (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate_ofCrAnList_ofCrAnList (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs φs' : List 𝓕.CrAnStates) :
𝓝ᶠ(ofCrAnList φs' * ofCrAnState φc * ofCrAnState φa * ofCrAnList φs) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
𝓝ᶠ(ofCrAnList φs' * ofCrAnState φa * ofCrAnState φc * ofCrAnList φs) := by
rw [mul_assoc, mul_assoc, ← ofCrAnList_cons, ← ofCrAnList_cons, ← ofCrAnList_append]
rw [normalOrder_ofCrAnList, normalOrderSign_swap_create_annihlate φc φa hφc hφa]
rw [normalOrderList_swap_create_annihlate φc φa hφc hφa, ← smul_smul, ← normalOrder_ofCrAnList]
rw [normalOrderF_ofCrAnList, normalOrderSign_swap_create_annihlate φc φa hφc hφa]
rw [normalOrderList_swap_create_annihlate φc φa hφc hφa, ← smul_smul, ← normalOrderF_ofCrAnList]
rw [ofCrAnList_append, ofCrAnList_cons, ofCrAnList_cons]
noncomm_ring
lemma normalOrder_swap_create_annihlate_ofCrAnList (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate_ofCrAnList (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(φs : List 𝓕.CrAnStates) (a : 𝓕.CrAnAlgebra) :
𝓝ᶠ(ofCrAnList φs * ofCrAnState φc * ofCrAnState φa * a) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
𝓝ᶠ(ofCrAnList φs * ofCrAnState φa * ofCrAnState φc * a) := by
change (normalOrder ∘ₗ mulLinearMap (ofCrAnList φs * ofCrAnState φc * ofCrAnState φa)) a =
(smulLinearMap _ ∘ₗ normalOrder ∘ₗ
change (normalOrderF ∘ₗ mulLinearMap (ofCrAnList φs * ofCrAnState φc * ofCrAnState φa)) a =
(smulLinearMap _ ∘ₗ normalOrderF ∘ₗ
mulLinearMap (ofCrAnList φs * ofCrAnState φa * ofCrAnState φc)) a
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) a
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate_ofCrAnList_ofCrAnList φc φa hφc hφa]
rw [normalOrderF_swap_create_annihlate_ofCrAnList_ofCrAnList φc φa hφc hφa]
rfl
lemma normalOrder_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_swap_create_annihlate (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.CrAnAlgebra) :
𝓝ᶠ(a * ofCrAnState φc * ofCrAnState φa * b) = 𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa) •
𝓝ᶠ(a * ofCrAnState φa * ofCrAnState φc * b) := by
rw [mul_assoc, mul_assoc, mul_assoc, mul_assoc]
change (normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φc * (ofCrAnState φa * b))) a =
change (normalOrderF ∘ₗ mulLinearMap.flip (ofCrAnState φc * (ofCrAnState φa * b))) a =
(smulLinearMap (𝓢(𝓕 |>ₛ φc, 𝓕 |>ₛ φa)) ∘ₗ
normalOrder ∘ₗ mulLinearMap.flip (ofCrAnState φa * (ofCrAnState φc * b))) a
normalOrderF ∘ₗ mulLinearMap.flip (ofCrAnState φa * (ofCrAnState φc * b))) a
refine LinearMap.congr_fun (ofCrAnListBasis.ext fun l ↦ ?_) _
simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk, instCommGroup.eq_1, ← mul_assoc,
normalOrder_swap_create_annihlate_ofCrAnList φc φa hφc hφa]
normalOrderF_swap_create_annihlate_ofCrAnList φc φa hφc hφa]
rfl
lemma normalOrder_superCommute_create_annihilate (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_superCommuteF_create_annihilate (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.CrAnAlgebra) :
𝓝ᶠ(a * [ofCrAnState φc, ofCrAnState φa]ₛca * b) = 0 := by
simp only [superCommute_ofCrAnState_ofCrAnState, instCommGroup.eq_1, Algebra.smul_mul_assoc]
simp only [superCommuteF_ofCrAnState_ofCrAnState, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [mul_sub, sub_mul, map_sub, ← smul_mul_assoc, ← mul_assoc, ← mul_assoc,
normalOrder_swap_create_annihlate φc φa hφc hφa]
normalOrderF_swap_create_annihlate φc φa hφc hφa]
simp
lemma normalOrder_superCommute_annihilate_create (φc φa : 𝓕.CrAnStates)
lemma normalOrderF_superCommuteF_annihilate_create (φc φa : 𝓕.CrAnStates)
(hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(a b : 𝓕.CrAnAlgebra) :
𝓝ᶠ(a * [ofCrAnState φa, ofCrAnState φc]ₛca * b) = 0 := by
rw [superCommute_ofCrAnState_ofCrAnState_symm]
rw [superCommuteF_ofCrAnState_ofCrAnState_symm]
simp only [instCommGroup.eq_1, neg_smul, mul_neg, Algebra.mul_smul_comm, neg_mul,
Algebra.smul_mul_assoc, map_neg, map_smul, neg_eq_zero, smul_eq_zero]
exact Or.inr (normalOrder_superCommute_create_annihilate φc φa hφc hφa ..)
exact Or.inr (normalOrderF_superCommuteF_create_annihilate φc φa hφc hφa ..)
lemma normalOrder_swap_crPart_anPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * (crPart φ) * (anPart φ') * b) =
lemma normalOrderF_swap_crPartF_anPartF (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * (crPartF φ) * (anPartF φ') * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓝ᶠ(a * (anPart φ') * (crPart φ) * b) := by
𝓝ᶠ(a * (anPartF φ') * (crPartF φ) * b) := by
match φ, φ' with
| _, .inAsymp φ' => simp
| .outAsymp φ, _ => simp
| .position φ, .position φ' =>
simp only [crPart_position, anPart_position, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
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]
rfl; rfl
| .inAsymp φ, .outAsymp φ' =>
simp only [crPart_negAsymp, anPart_posAsymp, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
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]
rfl; rfl
| .inAsymp φ, .position φ' =>
simp only [crPart_negAsymp, anPart_position, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
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]
rfl; rfl
| .position φ, .outAsymp φ' =>
simp only [crPart_position, anPart_posAsymp, instCommGroup.eq_1]
rw [normalOrder_swap_create_annihlate]
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]
rfl; rfl
/-!
## Normal ordering for an anPart and crPart
## Normal ordering for an anPartF and crPartF
Using the results from above.
-/
lemma normalOrder_swap_anPart_crPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * (anPart φ) * (crPart φ') * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝ᶠ(a * (crPart φ') *
(anPart φ) * b) := by
simp [normalOrder_swap_crPart_anPart, smul_smul]
lemma normalOrderF_swap_anPartF_crPartF (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * (anPartF φ) * (crPartF φ') * b) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝ᶠ(a * (crPartF φ') *
(anPartF φ) * b) := by
simp [normalOrderF_swap_crPartF_anPartF, smul_smul]
lemma normalOrder_superCommute_crPart_anPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * superCommute
(crPart φ) (anPart φ') * b) = 0 := by
lemma normalOrderF_superCommuteF_crPartF_anPartF (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * superCommuteF
(crPartF φ) (anPartF φ') * b) = 0 := by
match φ, φ' with
| _, .inAsymp φ' => simp
| .outAsymp φ', _ => simp
| .position φ, .position φ' =>
rw [crPart_position, anPart_position]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
rw [crPartF_position, anPartF_position]
exact normalOrderF_superCommuteF_create_annihilate _ _ rfl rfl ..
| .inAsymp φ, .outAsymp φ' =>
rw [crPart_negAsymp, anPart_posAsymp]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
rw [crPartF_negAsymp, anPartF_posAsymp]
exact normalOrderF_superCommuteF_create_annihilate _ _ rfl rfl ..
| .inAsymp φ, .position φ' =>
rw [crPart_negAsymp, anPart_position]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
rw [crPartF_negAsymp, anPartF_position]
exact normalOrderF_superCommuteF_create_annihilate _ _ rfl rfl ..
| .position φ, .outAsymp φ' =>
rw [crPart_position, anPart_posAsymp]
exact normalOrder_superCommute_create_annihilate _ _ rfl rfl ..
rw [crPartF_position, anPartF_posAsymp]
exact normalOrderF_superCommuteF_create_annihilate _ _ rfl rfl ..
lemma normalOrder_superCommute_anPart_crPart (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * superCommute
(anPart φ) (crPart φ') * b) = 0 := by
lemma normalOrderF_superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) (a b : CrAnAlgebra 𝓕) :
𝓝ᶠ(a * superCommuteF
(anPartF φ) (crPartF φ') * b) = 0 := by
match φ, φ' with
| .inAsymp φ', _ => simp
| _, .outAsymp φ' => simp
| .position φ, .position φ' =>
rw [anPart_position, crPart_position]
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
rw [anPartF_position, crPartF_position]
exact normalOrderF_superCommuteF_annihilate_create _ _ rfl rfl ..
| .outAsymp φ', .inAsymp φ =>
simp only [anPart_posAsymp, crPart_negAsymp]
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
simp only [anPartF_posAsymp, crPartF_negAsymp]
exact normalOrderF_superCommuteF_annihilate_create _ _ rfl rfl ..
| .position φ', .inAsymp φ =>
simp only [anPart_position, crPart_negAsymp]
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
simp only [anPartF_position, crPartF_negAsymp]
exact normalOrderF_superCommuteF_annihilate_create _ _ rfl rfl ..
| .outAsymp φ, .position φ' =>
simp only [anPart_posAsymp, crPart_position]
exact normalOrder_superCommute_annihilate_create _ _ rfl rfl ..
simp only [anPartF_posAsymp, crPartF_position]
exact normalOrderF_superCommuteF_annihilate_create _ _ rfl rfl ..
/-!
@ -268,53 +269,53 @@ lemma normalOrder_superCommute_anPart_crPart (φ φ' : 𝓕.States) (a b : CrAnA
-/
@[simp]
lemma normalOrder_crPart_mul_crPart (φ φ' : 𝓕.States) :
𝓝ᶠ(crPart φ * crPart φ') =
crPart φ * crPart φ' := by
rw [normalOrder_crPart_mul]
conv_lhs => rw [← mul_one (crPart φ')]
rw [normalOrder_crPart_mul, normalOrder_one]
lemma normalOrderF_crPartF_mul_crPartF (φ φ' : 𝓕.States) :
𝓝ᶠ(crPartF φ * crPartF φ') =
crPartF φ * crPartF φ' := by
rw [normalOrderF_crPartF_mul]
conv_lhs => rw [← mul_one (crPartF φ')]
rw [normalOrderF_crPartF_mul, normalOrderF_one]
simp
@[simp]
lemma normalOrder_anPart_mul_anPart (φ φ' : 𝓕.States) :
𝓝ᶠ(anPart φ * anPart φ') =
anPart φ * anPart φ' := by
rw [normalOrder_mul_anPart]
conv_lhs => rw [← one_mul (anPart φ)]
rw [normalOrder_mul_anPart, normalOrder_one]
lemma normalOrderF_anPartF_mul_anPartF (φ φ' : 𝓕.States) :
𝓝ᶠ(anPartF φ * anPartF φ') =
anPartF φ * anPartF φ' := by
rw [normalOrderF_mul_anPartF]
conv_lhs => rw [← one_mul (anPartF φ)]
rw [normalOrderF_mul_anPartF, normalOrderF_one]
simp
@[simp]
lemma normalOrder_crPart_mul_anPart (φ φ' : 𝓕.States) :
𝓝ᶠ(crPart φ * anPart φ') =
crPart φ * anPart φ' := by
rw [normalOrder_crPart_mul]
conv_lhs => rw [← one_mul (anPart φ')]
rw [normalOrder_mul_anPart, normalOrder_one]
lemma normalOrderF_crPartF_mul_anPartF (φ φ' : 𝓕.States) :
𝓝ᶠ(crPartF φ * anPartF φ') =
crPartF φ * anPartF φ' := by
rw [normalOrderF_crPartF_mul]
conv_lhs => rw [← one_mul (anPartF φ')]
rw [normalOrderF_mul_anPartF, normalOrderF_one]
simp
@[simp]
lemma normalOrder_anPart_mul_crPart (φ φ' : 𝓕.States) :
𝓝ᶠ(anPart φ * crPart φ') =
lemma normalOrderF_anPartF_mul_crPartF (φ φ' : 𝓕.States) :
𝓝ᶠ(anPartF φ * crPartF φ') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
(crPart φ' * anPart φ) := by
conv_lhs => rw [← one_mul (anPart φ * crPart φ')]
conv_lhs => rw [← mul_one (1 * (anPart φ *
crPart φ'))]
rw [← mul_assoc, normalOrder_swap_anPart_crPart]
(crPartF φ' * anPartF φ) := by
conv_lhs => rw [← one_mul (anPartF φ * crPartF φ')]
conv_lhs => rw [← mul_one (1 * (anPartF φ *
crPartF φ'))]
rw [← mul_assoc, normalOrderF_swap_anPartF_crPartF]
simp
lemma normalOrder_ofState_mul_ofState (φ φ' : 𝓕.States) :
lemma normalOrderF_ofState_mul_ofState (φ φ' : 𝓕.States) :
𝓝ᶠ(ofState φ * ofState φ') =
crPart φ * crPart φ' +
crPartF φ * crPartF φ' +
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
(crPart φ' * anPart φ) +
crPart φ * anPart φ' +
anPart φ * anPart φ' := by
rw [ofState_eq_crPart_add_anPart, ofState_eq_crPart_add_anPart, mul_add, add_mul, add_mul]
simp only [map_add, normalOrder_crPart_mul_crPart, normalOrder_anPart_mul_crPart,
instCommGroup.eq_1, normalOrder_crPart_mul_anPart, normalOrder_anPart_mul_anPart]
(crPartF φ' * anPartF φ) +
crPartF φ * anPartF φ' +
anPartF φ * anPartF φ' := by
rw [ofState_eq_crPartF_add_anPartF, ofState_eq_crPartF_add_anPartF, mul_add, add_mul, add_mul]
simp only [map_add, normalOrderF_crPartF_mul_crPartF, normalOrderF_anPartF_mul_crPartF,
instCommGroup.eq_1, normalOrderF_crPartF_mul_anPartF, normalOrderF_anPartF_mul_anPartF]
abel
/-!
@ -325,21 +326,21 @@ lemma normalOrder_ofState_mul_ofState (φ φ' : 𝓕.States) :
TODO "Split the following two lemmas up into smaller parts."
lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
lemma normalOrderF_superCommuteF_ofCrAnList_create_create_ofCrAnList
(φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create) (φs φs' : List 𝓕.CrAnStates) :
(𝓝ᶠ(ofCrAnList φs * [ofCrAnState φc, ofCrAnState φc']ₛca * ofCrAnList φs')) =
normalOrderSign (φs ++ φc' :: φc :: φs') •
(ofCrAnList (createFilter φs) * [ofCrAnState φc, ofCrAnState φc']ₛca *
ofCrAnList (createFilter φs') * ofCrAnList (annihilateFilter (φs ++ φs'))) := by
rw [superCommute_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
rw [superCommuteF_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
conv_lhs =>
lhs; rhs
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append, ← ofCrAnList_append,
← ofCrAnList_append]
conv_lhs =>
lhs
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrderF_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_create _ hφc, createFilter_singleton_create _ hφc']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -358,7 +359,7 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
rhs
rw [map_smul]
rhs
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrderF_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_create _ hφc, createFilter_singleton_create _ hφc']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -384,7 +385,7 @@ lemma normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
ofCrAnList_singleton]
rw [ofCrAnList_append, ofCrAnList_singleton, ofCrAnList_singleton, smul_mul_assoc]
lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
lemma normalOrderF_superCommuteF_ofCrAnList_annihilate_annihilate_ofCrAnList
(φa φa' : 𝓕.CrAnStates)
(hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate)
@ -394,14 +395,14 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
(ofCrAnList (createFilter (φs ++ φs'))
* ofCrAnList (annihilateFilter φs) * [ofCrAnState φa, ofCrAnState φa']ₛca
* ofCrAnList (annihilateFilter φs')) := by
rw [superCommute_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
rw [superCommuteF_ofCrAnState_ofCrAnState, mul_sub, sub_mul, map_sub]
conv_lhs =>
lhs; rhs
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append, ← ofCrAnList_append,
← ofCrAnList_append]
conv_lhs =>
lhs
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrderF_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_annihilate _ hφa, createFilter_singleton_annihilate _ hφa']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -421,7 +422,7 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
rhs
rw [map_smul]
rhs
rw [normalOrder_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [normalOrderF_ofCrAnList, normalOrderList_eq_createFilter_append_annihilateFilter]
rw [createFilter_append, createFilter_append, createFilter_append,
createFilter_singleton_annihilate _ hφa, createFilter_singleton_annihilate _ hφa']
rw [annihilateFilter_append, annihilateFilter_append, annihilateFilter_append,
@ -458,14 +459,14 @@ lemma normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
-/
lemma ofCrAnList_superCommute_normalOrder_ofCrAnList (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnList_superCommuteF_normalOrderF_ofCrAnList (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnList φs, 𝓝ᶠ(ofCrAnList φs')]ₛca =
ofCrAnList φs * 𝓝ᶠ(ofCrAnList φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofCrAnList φs') * ofCrAnList φs := by
simp [normalOrder_ofCrAnList, map_smul, superCommute_ofCrAnList_ofCrAnList, ofCrAnList_append,
simp [normalOrderF_ofCrAnList, map_smul, superCommuteF_ofCrAnList_ofCrAnList, ofCrAnList_append,
smul_sub, smul_smul, mul_comm]
lemma ofCrAnList_superCommute_normalOrder_ofStateList (φs : List 𝓕.CrAnStates)
lemma ofCrAnList_superCommuteF_normalOrderF_ofStateList (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, 𝓝ᶠ(ofStateList φs')]ₛca =
ofCrAnList φs * 𝓝ᶠ(ofStateList φs') -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnList φs := by
@ -473,7 +474,7 @@ lemma ofCrAnList_superCommute_normalOrder_ofStateList (φs : List 𝓕.CrAnState
← Finset.sum_sub_distrib, map_sum]
congr
funext n
rw [ofCrAnList_superCommute_normalOrder_ofCrAnList,
rw [ofCrAnList_superCommuteF_normalOrderF_ofCrAnList,
CrAnSection.statistics_eq_state_statistics]
/-!
@ -482,29 +483,29 @@ lemma ofCrAnList_superCommute_normalOrder_ofStateList (φs : List 𝓕.CrAnState
-/
lemma ofCrAnList_mul_normalOrder_ofStateList_eq_superCommute (φs : List 𝓕.CrAnStates)
lemma ofCrAnList_mul_normalOrderF_ofStateList_eq_superCommuteF (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) :
ofCrAnList φs * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnList φs
+ [ofCrAnList φs, 𝓝ᶠ(ofStateList φs')]ₛca := by
simp [ofCrAnList_superCommute_normalOrder_ofStateList]
simp [ofCrAnList_superCommuteF_normalOrderF_ofStateList]
lemma ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute (φ : 𝓕.CrAnStates)
lemma ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.States) : ofCrAnState φ * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs') * ofCrAnState φ
+ [ofCrAnState φ, 𝓝ᶠ(ofStateList φs')]ₛca := by
simp [← ofCrAnList_singleton, ofCrAnList_mul_normalOrder_ofStateList_eq_superCommute]
simp [← ofCrAnList_singleton, ofCrAnList_mul_normalOrderF_ofStateList_eq_superCommuteF]
lemma anPart_mul_normalOrder_ofStateList_eq_superCommute (φ : 𝓕.States)
lemma anPartF_mul_normalOrderF_ofStateList_eq_superCommuteF (φ : 𝓕.States)
(φs' : List 𝓕.States) :
anPart φ * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs' * anPart φ)
+ [anPart φ, 𝓝ᶠ(ofStateList φs')]ₛca := by
rw [normalOrder_mul_anPart]
anPartF φ * 𝓝ᶠ(ofStateList φs') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝ᶠ(ofStateList φs' * anPartF φ)
+ [anPartF φ, 𝓝ᶠ(ofStateList φs')]ₛca := by
rw [normalOrderF_mul_anPartF]
match φ with
| .inAsymp φ => simp
| .position φ => simp [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute, crAnStatistics]
| .outAsymp φ => simp [ofCrAnState_mul_normalOrder_ofStateList_eq_superCommute, crAnStatistics]
| .position φ => simp [ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF, crAnStatistics]
| .outAsymp φ => simp [ofCrAnState_mul_normalOrderF_ofStateList_eq_superCommuteF, crAnStatistics]
end

385
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/SuperCommute.lean
View file

@ -26,7 +26,7 @@ open FieldStatistic
/-- The super commutor on the creation and annihlation algebra. For two bosonic operators
or a bosonic and fermionic operator this corresponds to the usual commutator
whilst for two fermionic operators this corresponds to the anti-commutator. -/
noncomputable def superCommute : 𝓕.CrAnAlgebra →ₗ[ℂ] 𝓕.CrAnAlgebra →ₗ[ℂ] 𝓕.CrAnAlgebra :=
noncomputable def superCommuteF : 𝓕.CrAnAlgebra →ₗ[ℂ] 𝓕.CrAnAlgebra →ₗ[ℂ] 𝓕.CrAnAlgebra :=
Basis.constr ofCrAnListBasis ℂ fun φs =>
Basis.constr ofCrAnListBasis ℂ fun φs' =>
ofCrAnList (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnList (φs' ++ φs)
@ -34,7 +34,7 @@ noncomputable def superCommute : 𝓕.CrAnAlgebra →ₗ[ℂ] 𝓕.CrAnAlgebra
/-- The super commutor on the creation and annihlation algebra. For two bosonic operators
or a bosonic and fermionic operator this corresponds to the usual commutator
whilst for two fermionic operators this corresponds to the anti-commutator. -/
scoped[FieldSpecification.CrAnAlgebra] notation "[" φs "," φs' "]ₛca" => superCommute φs φs'
scoped[FieldSpecification.CrAnAlgebra] notation "[" φs "," φs' "]ₛca" => superCommuteF φs φs'
/-!
@ -42,35 +42,35 @@ scoped[FieldSpecification.CrAnAlgebra] notation "[" φs "," φs' "]ₛca" => sup
-/
lemma superCommute_ofCrAnList_ofCrAnList (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnList_ofCrAnList (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnList φs, ofCrAnList φs']ₛca =
ofCrAnList (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnList (φs' ++ φs) := by
rw [← ofListBasis_eq_ofList, ← ofListBasis_eq_ofList]
simp only [superCommute, Basis.constr_basis]
simp only [superCommuteF, Basis.constr_basis]
lemma superCommute_ofCrAnState_ofCrAnState (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnState_ofCrAnState (φ φ' : 𝓕.CrAnStates) :
[ofCrAnState φ, ofCrAnState φ']ₛca =
ofCrAnState φ * ofCrAnState φ' - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofCrAnState φ' * ofCrAnState φ := by
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton]
rw [superCommute_ofCrAnList_ofCrAnList, ofCrAnList_append]
rw [superCommuteF_ofCrAnList_ofCrAnList, ofCrAnList_append]
congr
rw [ofCrAnList_append]
rw [FieldStatistic.ofList_singleton, FieldStatistic.ofList_singleton, smul_mul_assoc]
lemma superCommute_ofCrAnList_ofStatesList (φcas : List 𝓕.CrAnStates) (φs : List 𝓕.States) :
lemma superCommuteF_ofCrAnList_ofStatesList (φcas : List 𝓕.CrAnStates) (φs : List 𝓕.States) :
[ofCrAnList φcas, ofStateList φs]ₛca = ofCrAnList φcas * ofStateList φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofStateList φs * ofCrAnList φcas := by
conv_lhs => rw [ofStateList_sum]
rw [map_sum]
conv_lhs =>
enter [2, x]
rw [superCommute_ofCrAnList_ofCrAnList, CrAnSection.statistics_eq_state_statistics,
rw [superCommuteF_ofCrAnList_ofCrAnList, CrAnSection.statistics_eq_state_statistics,
ofCrAnList_append, ofCrAnList_append]
rw [Finset.sum_sub_distrib, ← Finset.mul_sum, ← Finset.smul_sum,
← Finset.sum_mul, ← ofStateList_sum]
simp
lemma superCommute_ofStateList_ofStatesList (φ : List 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_ofStateList_ofStatesList (φ : List 𝓕.States) (φs : List 𝓕.States) :
[ofStateList φ, ofStateList φs]ₛca = ofStateList φ * ofStateList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs * ofStateList φ := by
conv_lhs => rw [ofStateList_sum]
@ -78,252 +78,246 @@ lemma superCommute_ofStateList_ofStatesList (φ : List 𝓕.States) (φs : List
Algebra.smul_mul_assoc]
conv_lhs =>
enter [2, x]
rw [superCommute_ofCrAnList_ofStatesList]
rw [superCommuteF_ofCrAnList_ofStatesList]
simp only [instCommGroup.eq_1, CrAnSection.statistics_eq_state_statistics,
Algebra.smul_mul_assoc, Finset.sum_sub_distrib]
rw [← Finset.sum_mul, ← Finset.smul_sum, ← Finset.mul_sum, ← ofStateList_sum]
lemma superCommute_ofState_ofStatesList (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma superCommuteF_ofState_ofStatesList (φ : 𝓕.States) (φs : List 𝓕.States) :
[ofState φ, ofStateList φs]ₛca = ofState φ * ofStateList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs * ofState φ := by
rw [← ofStateList_singleton, superCommute_ofStateList_ofStatesList, ofStateList_singleton]
rw [← ofStateList_singleton, superCommuteF_ofStateList_ofStatesList, ofStateList_singleton]
simp
lemma superCommute_ofStateList_ofState (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma superCommuteF_ofStateList_ofState (φs : List 𝓕.States) (φ : 𝓕.States) :
[ofStateList φs, ofState φ]ₛca = ofStateList φs * ofState φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofStateList φs := by
rw [← ofStateList_singleton, superCommute_ofStateList_ofStatesList, ofStateList_singleton]
rw [← ofStateList_singleton, superCommuteF_ofStateList_ofStatesList, ofStateList_singleton]
simp
lemma superCommute_anPart_crPart (φ φ' : 𝓕.States) :
[anPart φ, crPart φ']ₛca =
anPart φ * crPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ := by
lemma superCommuteF_anPartF_crPartF (φ φ' : 𝓕.States) :
[anPartF φ, crPartF φ']ₛca = anPartF φ * crPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * anPartF φ := by
match φ, φ' with
| States.inAsymp φ, _ =>
simp
| _, States.outAsymp φ =>
simp only [crPart_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
simp only [crPartF_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
simp only [anPart_position, crPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_position, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.outAsymp φ, States.position φ' =>
simp only [anPart_posAsymp, crPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_posAsymp, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.position φ, States.inAsymp φ' =>
simp only [anPart_position, crPart_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_position, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp only [List.singleton_append, instCommGroup.eq_1, crAnStatistics,
FieldStatistic.ofList_singleton, Function.comp_apply, crAnStatesToStates_prod, ←
ofCrAnList_append]
| States.outAsymp φ, States.inAsymp φ' =>
simp only [anPart_posAsymp, crPart_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_posAsymp, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
lemma superCommute_crPart_anPart (φ φ' : 𝓕.States) :
[crPart φ, anPart φ']ₛca =
crPart φ * anPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
anPart φ' * crPart φ := by
lemma superCommuteF_crPartF_anPartF (φ φ' : 𝓕.States) :
[crPartF φ, anPartF φ']ₛca = crPartF φ * anPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * crPartF φ := by
match φ, φ' with
| States.outAsymp φ, _ =>
simp only [crPart_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
simp only [crPartF_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
mul_zero, sub_self]
| _, States.inAsymp φ =>
simp only [anPart_negAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
simp only [anPartF_negAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
simp only [crPart_position, anPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_position, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.position φ, States.outAsymp φ' =>
simp only [crPart_position, anPart_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_position, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.inAsymp φ, States.position φ' =>
simp only [crPart_negAsymp, anPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_negAsymp, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.inAsymp φ, States.outAsymp φ' =>
simp only [crPart_negAsymp, anPart_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_negAsymp, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
lemma superCommute_crPart_crPart (φ φ' : 𝓕.States) :
[crPart φ, crPart φ']ₛca =
crPart φ * crPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
crPart φ' * crPart φ := by
lemma superCommuteF_crPartF_crPartF (φ φ' : 𝓕.States) :
[crPartF φ, crPartF φ']ₛca = crPartF φ * crPartF φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * crPartF φ := by
match φ, φ' with
| States.outAsymp φ, _ =>
simp only [crPart_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
simp only [crPartF_posAsymp, map_zero, LinearMap.zero_apply, zero_mul, instCommGroup.eq_1,
mul_zero, sub_self]
| _, States.outAsymp φ =>
simp only [crPart_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul, sub_self]
simp only [crPartF_posAsymp, map_zero, mul_zero, instCommGroup.eq_1, smul_zero, zero_mul,
sub_self]
| States.position φ, States.position φ' =>
simp only [crPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.position φ, States.inAsymp φ' =>
simp only [crPart_position, crPart_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_position, crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.inAsymp φ, States.position φ' =>
simp only [crPart_negAsymp, crPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_negAsymp, crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.inAsymp φ, States.inAsymp φ' =>
simp only [crPart_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
lemma superCommute_anPart_anPart (φ φ' : 𝓕.States) :
[anPart φ, anPart φ']ₛca =
anPart φ * anPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
anPart φ' * anPart φ := by
lemma superCommuteF_anPartF_anPartF (φ φ' : 𝓕.States) :
[anPartF φ, anPartF φ']ₛca =
anPartF φ * anPartF φ' - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * anPartF φ := by
match φ, φ' with
| States.inAsymp φ, _ =>
simp
| _, States.inAsymp φ =>
simp
| States.position φ, States.position φ' =>
simp only [anPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.position φ, States.outAsymp φ' =>
simp only [anPart_position, anPart_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_position, anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.outAsymp φ, States.position φ' =>
simp only [anPart_posAsymp, anPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_posAsymp, anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
| States.outAsymp φ, States.outAsymp φ' =>
simp only [anPart_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
simp only [anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [crAnStatistics, ← ofCrAnList_append]
lemma superCommute_crPart_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[crPart φ, ofStateList φs]ₛca =
crPart φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs *
crPart φ := by
lemma superCommuteF_crPartF_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[crPartF φ, ofStateList φs]ₛca =
crPartF φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofStateList φs *
crPartF φ := by
match φ with
| States.inAsymp φ =>
simp only [crPart_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofStatesList]
simp only [crPartF_negAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofStatesList]
simp [crAnStatistics]
| States.position φ =>
simp only [crPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofStatesList]
simp only [crPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofStatesList]
simp [crAnStatistics]
| States.outAsymp φ =>
simp
lemma superCommute_anPart_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPart φ, ofStateList φs]ₛca =
anPart φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) •
ofStateList φs * anPart φ := by
lemma superCommuteF_anPartF_ofStateList (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPartF φ, ofStateList φs]ₛca =
anPartF φ * ofStateList φs - 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) •
ofStateList φs * anPartF φ := by
match φ with
| States.inAsymp φ =>
simp
| States.position φ =>
simp only [anPart_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofStatesList]
simp only [anPartF_position, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofStatesList]
simp [crAnStatistics]
| States.outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofStatesList]
simp only [anPartF_posAsymp, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofStatesList]
simp [crAnStatistics]
lemma superCommute_crPart_ofState (φ φ' : 𝓕.States) :
[crPart φ, ofState φ']ₛca =
crPart φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * crPart φ := by
rw [← ofStateList_singleton, superCommute_crPart_ofStateList]
lemma superCommuteF_crPartF_ofState (φ φ' : 𝓕.States) :
[crPartF φ, ofState φ']ₛca =
crPartF φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * crPartF φ := by
rw [← ofStateList_singleton, superCommuteF_crPartF_ofStateList]
simp
lemma superCommute_anPart_ofState (φ φ' : 𝓕.States) :
[anPart φ, ofState φ']ₛca =
anPart φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * anPart φ := by
rw [← ofStateList_singleton, superCommute_anPart_ofStateList]
lemma superCommuteF_anPartF_ofState (φ φ' : 𝓕.States) :
[anPartF φ, ofState φ']ₛca =
anPartF φ * ofState φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofState φ' * anPartF φ := by
rw [← ofStateList_singleton, superCommuteF_anPartF_ofStateList]
simp
/-!
## Mul equal superCommute
## Mul equal superCommuteF
Lemmas which rewrite a multiplication of two elements of the algebra as their commuted
multiplication with a sign plus the super commutor.
-/
lemma ofCrAnList_mul_ofCrAnList_eq_superCommute (φs φs' : List 𝓕.CrAnStates) :
lemma ofCrAnList_mul_ofCrAnList_eq_superCommuteF (φs φs' : List 𝓕.CrAnStates) :
ofCrAnList φs * ofCrAnList φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnList φs' * ofCrAnList φs
+ [ofCrAnList φs, ofCrAnList φs']ₛca := by
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp [ofCrAnList_append]
lemma ofCrAnState_mul_ofCrAnList_eq_superCommute (φ : 𝓕.CrAnStates) (φs' : List 𝓕.CrAnStates) :
lemma ofCrAnState_mul_ofCrAnList_eq_superCommuteF (φ : 𝓕.CrAnStates) (φs' : List 𝓕.CrAnStates) :
ofCrAnState φ * ofCrAnList φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofCrAnList φs' * ofCrAnState φ
+ [ofCrAnState φ, ofCrAnList φs']ₛca := by
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommute]
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommuteF]
simp
lemma ofStateList_mul_ofStateList_eq_superCommute (φs φs' : List 𝓕.States) :
lemma ofStateList_mul_ofStateList_eq_superCommuteF (φs φs' : List 𝓕.States) :
ofStateList φs * ofStateList φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofStateList φs' * ofStateList φs
+ [ofStateList φs, ofStateList φs']ₛca := by
rw [superCommute_ofStateList_ofStatesList]
rw [superCommuteF_ofStateList_ofStatesList]
simp
lemma ofState_mul_ofStateList_eq_superCommute (φ : 𝓕.States) (φs' : List 𝓕.States) :
lemma ofState_mul_ofStateList_eq_superCommuteF (φ : 𝓕.States) (φs' : List 𝓕.States) :
ofState φ * ofStateList φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofStateList φs' * ofState φ
+ [ofState φ, ofStateList φs']ₛca := by
rw [superCommute_ofState_ofStatesList]
rw [superCommuteF_ofState_ofStatesList]
simp
lemma ofStateList_mul_ofState_eq_superCommute (φs : List 𝓕.States) (φ : 𝓕.States) :
lemma ofStateList_mul_ofState_eq_superCommuteF (φs : List 𝓕.States) (φ : 𝓕.States) :
ofStateList φs * ofState φ = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * ofStateList φs
+ [ofStateList φs, ofState φ]ₛca := by
rw [superCommute_ofStateList_ofState]
rw [superCommuteF_ofStateList_ofState]
simp
lemma crPart_mul_anPart_eq_superCommute (φ φ' : 𝓕.States) :
crPart φ * anPart φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * crPart φ +
[crPart φ, anPart φ']ₛca := by
rw [superCommute_crPart_anPart]
lemma crPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
crPartF φ * anPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * crPartF φ +
[crPartF φ, anPartF φ']ₛca := by
rw [superCommuteF_crPartF_anPartF]
simp
lemma anPart_mul_crPart_eq_superCommute (φ φ' : 𝓕.States) :
anPart φ * crPart φ' =
lemma anPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
anPartF φ * crPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
crPart φ' * anPart φ +
[anPart φ, crPart φ']ₛca := by
rw [superCommute_anPart_crPart]
crPartF φ' * anPartF φ +
[anPartF φ, crPartF φ']ₛca := by
rw [superCommuteF_anPartF_crPartF]
simp
lemma crPart_mul_crPart_eq_superCommute (φ φ' : 𝓕.States) :
crPart φ * crPart φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * crPart φ +
[crPart φ, crPart φ']ₛca := by
rw [superCommute_crPart_crPart]
lemma crPartF_mul_crPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
crPartF φ * crPartF φ' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPartF φ' * crPartF φ +
[crPartF φ, crPartF φ']ₛca := by
rw [superCommuteF_crPartF_crPartF]
simp
lemma anPart_mul_anPart_eq_superCommute (φ φ' : 𝓕.States) :
anPart φ * anPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * anPart φ +
[anPart φ, anPart φ']ₛca := by
rw [superCommute_anPart_anPart]
lemma anPartF_mul_anPartF_eq_superCommuteF (φ φ' : 𝓕.States) :
anPartF φ * anPartF φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPartF φ' * anPartF φ +
[anPartF φ, anPartF φ']ₛca := by
rw [superCommuteF_anPartF_anPartF]
simp
lemma ofCrAnList_mul_ofStateList_eq_superCommute (φs : List 𝓕.CrAnStates) (φs' : List 𝓕.States) :
lemma ofCrAnList_mul_ofStateList_eq_superCommuteF (φs : List 𝓕.CrAnStates) (φs' : List 𝓕.States) :
ofCrAnList φs * ofStateList φs' = 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofStateList φs' * ofCrAnList φs
+ [ofCrAnList φs, ofStateList φs']ₛca := by
rw [superCommute_ofCrAnList_ofStatesList]
rw [superCommuteF_ofCrAnList_ofStatesList]
simp
/-!
@ -332,10 +326,10 @@ lemma ofCrAnList_mul_ofStateList_eq_superCommute (φs : List 𝓕.CrAnStates) (
-/
lemma superCommute_ofCrAnList_ofCrAnList_symm (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnList_ofCrAnList_symm (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnList φs, ofCrAnList φs']ₛca =
(- 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs')) • [ofCrAnList φs', ofCrAnList φs]ₛca := by
rw [superCommute_ofCrAnList_ofCrAnList, superCommute_ofCrAnList_ofCrAnList, smul_sub]
rw [superCommuteF_ofCrAnList_ofCrAnList, superCommuteF_ofCrAnList_ofCrAnList, smul_sub]
simp only [instCommGroup.eq_1, neg_smul, sub_neg_eq_add]
rw [smul_smul]
conv_rhs =>
@ -344,10 +338,10 @@ lemma superCommute_ofCrAnList_ofCrAnList_symm (φs φs' : List 𝓕.CrAnStates)
simp only [one_smul]
abel
lemma superCommute_ofCrAnState_ofCrAnState_symm (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnState_ofCrAnState_symm (φ φ' : 𝓕.CrAnStates) :
[ofCrAnState φ, ofCrAnState φ']ₛca =
(- 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ')) • [ofCrAnState φ', ofCrAnState φ]ₛca := by
rw [superCommute_ofCrAnState_ofCrAnState, superCommute_ofCrAnState_ofCrAnState]
rw [superCommuteF_ofCrAnState_ofCrAnState, superCommuteF_ofCrAnState_ofCrAnState]
rw [smul_sub]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, neg_smul, sub_neg_eq_add]
rw [smul_smul]
@ -362,41 +356,42 @@ lemma superCommute_ofCrAnState_ofCrAnState_symm (φ φ' : 𝓕.CrAnStates) :
## Splitting the super commutor on lists into sums.
-/
lemma superCommute_ofCrAnList_ofCrAnList_cons (φ : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnList_ofCrAnList_cons (φ : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnList φs, ofCrAnList (φ :: φs')]ₛca =
[ofCrAnList φs, ofCrAnState φ]ₛca * ofCrAnList φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ)
• ofCrAnState φ * [ofCrAnList φs, ofCrAnList φs']ₛca := by
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
conv_rhs =>
lhs
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList, sub_mul, ← ofCrAnList_append]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList, sub_mul, ← ofCrAnList_append]
rhs
rw [FieldStatistic.ofList_singleton, ofCrAnList_append, ofCrAnList_singleton, smul_mul_assoc,
mul_assoc, ← ofCrAnList_append]
conv_rhs =>
rhs
rw [superCommute_ofCrAnList_ofCrAnList, mul_sub, smul_mul_assoc]
rw [superCommuteF_ofCrAnList_ofCrAnList, mul_sub, smul_mul_assoc]
simp only [instCommGroup.eq_1, List.cons_append, List.append_assoc, List.nil_append,
Algebra.mul_smul_comm, Algebra.smul_mul_assoc, sub_add_sub_cancel, sub_right_inj]
rw [← ofCrAnList_cons, smul_smul, FieldStatistic.ofList_cons_eq_mul]
simp only [instCommGroup, map_mul, mul_comm]
lemma superCommute_ofCrAnList_ofStateList_cons (φ : 𝓕.States) (φs : List 𝓕.CrAnStates)
lemma superCommuteF_ofCrAnList_ofStateList_cons (φ : 𝓕.States) (φs : List 𝓕.CrAnStates)
(φs' : List 𝓕.States) : [ofCrAnList φs, ofStateList (φ :: φs')]ₛca =
[ofCrAnList φs, ofState φ]ₛca * ofStateList φs' +
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofState φ * [ofCrAnList φs, ofStateList φs']ₛca := by
rw [superCommute_ofCrAnList_ofStatesList]
rw [superCommuteF_ofCrAnList_ofStatesList]
conv_rhs =>
lhs
rw [← ofStateList_singleton, superCommute_ofCrAnList_ofStatesList, sub_mul, mul_assoc,
rw [← ofStateList_singleton, superCommuteF_ofCrAnList_ofStatesList, sub_mul, mul_assoc,
← ofStateList_append]
rhs
rw [FieldStatistic.ofList_singleton, ofStateList_singleton, smul_mul_assoc,
smul_mul_assoc, mul_assoc]
conv_rhs =>
rhs
rw [superCommute_ofCrAnList_ofStatesList, mul_sub, smul_mul_assoc]
rw [superCommuteF_ofCrAnList_ofStatesList, mul_sub, smul_mul_assoc]
simp only [instCommGroup, Algebra.smul_mul_assoc, List.singleton_append, Algebra.mul_smul_comm,
sub_add_sub_cancel, sub_right_inj]
rw [ofStateList_cons, mul_assoc, smul_smul, FieldStatistic.ofList_cons_eq_mul]
@ -407,33 +402,34 @@ 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 superCommute_ofCrAnList_ofCrAnList_eq_sum (φs : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnList_ofCrAnList_eq_sum (φs : List 𝓕.CrAnStates) :
(φs' : List 𝓕.CrAnStates) → [ofCrAnList φs, ofCrAnList φs']ₛca =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofCrAnList (φs'.take n) * [ofCrAnList φs, ofCrAnState (φs'.get n)]ₛca *
ofCrAnList (φs'.drop (n + 1))
| [] => by
simp [← ofCrAnList_nil, superCommute_ofCrAnList_ofCrAnList]
simp [← ofCrAnList_nil, superCommuteF_ofCrAnList_ofCrAnList]
| φ :: φs' => by
rw [superCommute_ofCrAnList_ofCrAnList_cons, superCommute_ofCrAnList_ofCrAnList_eq_sum φs φs']
rw [superCommuteF_ofCrAnList_ofCrAnList_cons, superCommuteF_ofCrAnList_ofCrAnList_eq_sum φs φs']
conv_rhs => erw [Fin.sum_univ_succ]
congr 1
· simp
· simp [Finset.mul_sum, smul_smul, ofCrAnList_cons, mul_assoc,
FieldStatistic.ofList_cons_eq_mul, mul_comm]
lemma superCommute_ofCrAnList_ofStateList_eq_sum (φs : List 𝓕.CrAnStates) : (φs' : List 𝓕.States) →
lemma superCommuteF_ofCrAnList_ofStateList_eq_sum (φs : List 𝓕.CrAnStates) : (φs' : List 𝓕.States) →
[ofCrAnList φs, ofStateList φs']ₛca =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofStateList (φs'.take n) * [ofCrAnList φs, ofState (φs'.get n)]ₛca *
ofStateList (φs'.drop (n + 1))
| [] => by
simp only [superCommute_ofCrAnList_ofStatesList, instCommGroup, ofList_empty,
simp only [superCommuteF_ofCrAnList_ofStatesList, instCommGroup, ofList_empty,
exchangeSign_bosonic, one_smul, List.length_nil, Finset.univ_eq_empty, List.take_nil,
List.get_eq_getElem, List.drop_nil, Finset.sum_empty]
simp
| φ :: φs' => by
rw [superCommute_ofCrAnList_ofStateList_cons, superCommute_ofCrAnList_ofStateList_eq_sum φs φs']
rw [superCommuteF_ofCrAnList_ofStateList_cons,
superCommuteF_ofCrAnList_ofStateList_eq_sum φs φs']
conv_rhs => erw [Fin.sum_univ_succ]
congr 1
· simp
@ -445,9 +441,9 @@ lemma summerCommute_jacobi_ofCrAnList (φs1 φs2 φs3 : List 𝓕.CrAnStates) :
𝓢(𝓕 |>ₛ φs1, 𝓕 |>ₛ φs3) •
(- 𝓢(𝓕 |>ₛ φs2, 𝓕 |>ₛ φs3) • [ofCrAnList φs3, [ofCrAnList φs1, ofCrAnList φs2]ₛca]ₛca -
𝓢(𝓕 |>ₛ φs1, 𝓕 |>ₛ φs2) • [ofCrAnList φs2, [ofCrAnList φs3, ofCrAnList φs1]ₛca]ₛca) := by
repeat rw [superCommute_ofCrAnList_ofCrAnList]
repeat rw [superCommuteF_ofCrAnList_ofCrAnList]
simp only [instCommGroup, map_sub, map_smul, neg_smul]
repeat rw [superCommute_ofCrAnList_ofCrAnList]
repeat rw [superCommuteF_ofCrAnList_ofCrAnList]
simp only [instCommGroup.eq_1, ofList_append_eq_mul, List.append_assoc]
by_cases h1 : (𝓕 |>ₛ φs1) = bosonic <;>
by_cases h2 : (𝓕 |>ₛ φs2) = bosonic <;>
@ -483,13 +479,14 @@ lemma summerCommute_jacobi_ofCrAnList (φs1 φs2 φs3 : List 𝓕.CrAnStates) :
simp only [h1, h2, h3, mul_self, map_one, one_smul, fermionic_exchangeSign_fermionic, neg_smul,
neg_sub]
abel
/-!
## Interaction with grading.
-/
lemma superCommute_grade {a b : 𝓕.CrAnAlgebra} {f1 f2 : FieldStatistic}
lemma superCommuteF_grade {a b : 𝓕.CrAnAlgebra} {f1 f2 : FieldStatistic}
(ha : a ∈ statisticSubmodule f1) (hb : b ∈ statisticSubmodule f2) :
[a, b]ₛca ∈ statisticSubmodule (f1 + f2) := by
let p (a2 : 𝓕.CrAnAlgebra) (hx : a2 ∈ statisticSubmodule f2) : Prop :=
@ -506,7 +503,7 @@ lemma superCommute_grade {a b : 𝓕.CrAnAlgebra} {f1 f2 : FieldStatistic}
· intro x hx
obtain ⟨φs', rfl, hφs'⟩ := hx
simp only [add_eq_mul, instCommGroup, p]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
apply Submodule.sub_mem _
· apply ofCrAnList_mem_statisticSubmodule_of
rw [ofList_append_eq_mul, hφs, hφs']
@ -531,7 +528,7 @@ lemma superCommute_grade {a b : 𝓕.CrAnAlgebra} {f1 f2 : FieldStatistic}
exact Submodule.smul_mem _ c hp1
· exact hb
lemma superCommute_bosonic_bosonic {a b : 𝓕.CrAnAlgebra}
lemma superCommuteF_bosonic_bosonic {a b : 𝓕.CrAnAlgebra}
(ha : a ∈ statisticSubmodule bosonic) (hb : b ∈ statisticSubmodule bosonic) :
[a, b]ₛca = a * b - b * a := by
let p (a2 : 𝓕.CrAnAlgebra) (hx : a2 ∈ statisticSubmodule bosonic) : Prop :=
@ -547,7 +544,7 @@ lemma superCommute_bosonic_bosonic {a b : 𝓕.CrAnAlgebra}
· intro x hx
obtain ⟨φs', rfl, hφs'⟩ := hx
simp only [p]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp [hφs, ofCrAnList_append]
· simp [p]
· intro x y hx hy hp1 hp2
@ -564,7 +561,7 @@ lemma superCommute_bosonic_bosonic {a b : 𝓕.CrAnAlgebra}
simp_all [p, smul_sub]
· exact hb
lemma superCommute_bosonic_fermionic {a b : 𝓕.CrAnAlgebra}
lemma superCommuteF_bosonic_fermionic {a b : 𝓕.CrAnAlgebra}
(ha : a ∈ statisticSubmodule bosonic) (hb : b ∈ statisticSubmodule fermionic) :
[a, b]ₛca = a * b - b * a := by
let p (a2 : 𝓕.CrAnAlgebra) (hx : a2 ∈ statisticSubmodule fermionic) : Prop :=
@ -580,7 +577,7 @@ lemma superCommute_bosonic_fermionic {a b : 𝓕.CrAnAlgebra}
· intro x hx
obtain ⟨φs', rfl, hφs'⟩ := hx
simp only [p]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp [hφs, hφs', ofCrAnList_append]
· simp [p]
· intro x y hx hy hp1 hp2
@ -597,7 +594,7 @@ lemma superCommute_bosonic_fermionic {a b : 𝓕.CrAnAlgebra}
simp_all [p, smul_sub]
· exact hb
lemma superCommute_fermionic_bonsonic {a b : 𝓕.CrAnAlgebra}
lemma superCommuteF_fermionic_bonsonic {a b : 𝓕.CrAnAlgebra}
(ha : a ∈ statisticSubmodule fermionic) (hb : b ∈ statisticSubmodule bosonic) :
[a, b]ₛca = a * b - b * a := by
let p (a2 : 𝓕.CrAnAlgebra) (hx : a2 ∈ statisticSubmodule bosonic) : Prop :=
@ -613,7 +610,7 @@ lemma superCommute_fermionic_bonsonic {a b : 𝓕.CrAnAlgebra}
· intro x hx
obtain ⟨φs', rfl, hφs'⟩ := hx
simp only [p]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp [hφs, hφs', ofCrAnList_append]
· simp [p]
· intro x y hx hy hp1 hp2
@ -630,33 +627,33 @@ lemma superCommute_fermionic_bonsonic {a b : 𝓕.CrAnAlgebra}
simp_all [p, smul_sub]
· exact hb
lemma superCommute_bonsonic {a b : 𝓕.CrAnAlgebra} (hb : b ∈ statisticSubmodule bosonic) :
lemma superCommuteF_bonsonic {a b : 𝓕.CrAnAlgebra} (hb : b ∈ statisticSubmodule bosonic) :
[a, b]ₛca = a * b - b * a := by
rw [← bosonicProj_add_fermionicProj a]
simp only [map_add, LinearMap.add_apply]
rw [superCommute_bosonic_bosonic (by simp) hb, superCommute_fermionic_bonsonic (by simp) hb]
rw [superCommuteF_bosonic_bosonic (by simp) hb, superCommuteF_fermionic_bonsonic (by simp) hb]
simp only [add_mul, mul_add]
abel
lemma bosonic_superCommute {a b : 𝓕.CrAnAlgebra} (ha : a ∈ statisticSubmodule bosonic) :
lemma bosonic_superCommuteF {a b : 𝓕.CrAnAlgebra} (ha : a ∈ statisticSubmodule bosonic) :
[a, b]ₛca = a * b - b * a := by
rw [← bosonicProj_add_fermionicProj b]
simp only [map_add, LinearMap.add_apply]
rw [superCommute_bosonic_bosonic ha (by simp), superCommute_bosonic_fermionic ha (by simp)]
rw [superCommuteF_bosonic_bosonic ha (by simp), superCommuteF_bosonic_fermionic ha (by simp)]
simp only [add_mul, mul_add]
abel
lemma superCommute_bonsonic_symm {a b : 𝓕.CrAnAlgebra} (hb : b ∈ statisticSubmodule bosonic) :
lemma superCommuteF_bonsonic_symm {a b : 𝓕.CrAnAlgebra} (hb : b ∈ statisticSubmodule bosonic) :
[a, b]ₛca = - [b, a]ₛca := by
rw [bosonic_superCommute hb, superCommute_bonsonic hb]
rw [bosonic_superCommuteF hb, superCommuteF_bonsonic hb]
simp
lemma bonsonic_superCommute_symm {a b : 𝓕.CrAnAlgebra} (ha : a ∈ statisticSubmodule bosonic) :
lemma bonsonic_superCommuteF_symm {a b : 𝓕.CrAnAlgebra} (ha : a ∈ statisticSubmodule bosonic) :
[a, b]ₛca = - [b, a]ₛca := by
rw [bosonic_superCommute ha, superCommute_bonsonic ha]
rw [bosonic_superCommuteF ha, superCommuteF_bonsonic ha]
simp
lemma superCommute_fermionic_fermionic {a b : 𝓕.CrAnAlgebra}
lemma superCommuteF_fermionic_fermionic {a b : 𝓕.CrAnAlgebra}
(ha : a ∈ statisticSubmodule fermionic) (hb : b ∈ statisticSubmodule fermionic) :
[a, b]ₛca = a * b + b * a := by
let p (a2 : 𝓕.CrAnAlgebra) (hx : a2 ∈ statisticSubmodule fermionic) : Prop :=
@ -672,7 +669,7 @@ lemma superCommute_fermionic_fermionic {a b : 𝓕.CrAnAlgebra}
· intro x hx
obtain ⟨φs', rfl, hφs'⟩ := hx
simp only [p]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp [hφs, hφs', ofCrAnList_append]
· simp [p]
· intro x y hx hy hp1 hp2
@ -689,27 +686,27 @@ lemma superCommute_fermionic_fermionic {a b : 𝓕.CrAnAlgebra}
simp_all [p, smul_sub]
· exact hb
lemma superCommute_fermionic_fermionic_symm {a b : 𝓕.CrAnAlgebra}
lemma superCommuteF_fermionic_fermionic_symm {a b : 𝓕.CrAnAlgebra}
(ha : a ∈ statisticSubmodule fermionic) (hb : b ∈ statisticSubmodule fermionic) :
[a, b]ₛca = [b, a]ₛca := by
rw [superCommute_fermionic_fermionic ha hb]
rw [superCommute_fermionic_fermionic hb ha]
rw [superCommuteF_fermionic_fermionic ha hb]
rw [superCommuteF_fermionic_fermionic hb ha]
abel
lemma superCommute_expand_bosonicProj_fermionicProj (a b : 𝓕.CrAnAlgebra) :
lemma superCommuteF_expand_bosonicProj_fermionicProj (a b : 𝓕.CrAnAlgebra) :
[a, b]ₛca = bosonicProj a * bosonicProj b - bosonicProj b * bosonicProj a +
bosonicProj a * fermionicProj b - fermionicProj b * bosonicProj a +
fermionicProj a * bosonicProj b - bosonicProj b * fermionicProj a +
fermionicProj a * fermionicProj b + fermionicProj b * fermionicProj a := by
conv_lhs => rw [← bosonicProj_add_fermionicProj a, ← bosonicProj_add_fermionicProj b]
simp only [map_add, LinearMap.add_apply]
rw [superCommute_bonsonic (by simp),
superCommute_fermionic_bonsonic (by simp) (by simp),
superCommute_bosonic_fermionic (by simp) (by simp),
superCommute_fermionic_fermionic (by simp) (by simp)]
rw [superCommuteF_bonsonic (by simp),
superCommuteF_fermionic_bonsonic (by simp) (by simp),
superCommuteF_bosonic_fermionic (by simp) (by simp),
superCommuteF_fermionic_fermionic (by simp) (by simp)]
abel
lemma superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnList φs, ofCrAnList φs']ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnList φs, ofCrAnList φs']ₛca ∈ statisticSubmodule fermionic := by
by_cases h1 : (𝓕 |>ₛ φs) = bosonic <;> by_cases h2 : (𝓕 |>ₛ φs') = bosonic
@ -718,7 +715,7 @@ lemma superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _ h1
apply ofCrAnList_mem_statisticSubmodule_of _ _ h2
· right
@ -726,7 +723,7 @@ lemma superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _ h1
apply ofCrAnList_mem_statisticSubmodule_of _ _ (by simpa using h2)
· right
@ -734,7 +731,7 @@ lemma superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _ (by simpa using h1)
apply ofCrAnList_mem_statisticSubmodule_of _ _ h2
· left
@ -742,47 +739,47 @@ lemma superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic (φs φs' : List
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _ (by simpa using h1)
apply ofCrAnList_mem_statisticSubmodule_of _ _ (by simpa using h2)
lemma superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic (φ φ' : 𝓕.CrAnStates) :
lemma superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic (φ φ' : 𝓕.CrAnStates) :
[ofCrAnState φ, ofCrAnState φ']ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnState φ, ofCrAnState φ']ₛca ∈ statisticSubmodule fermionic := by
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton]
exact superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ] [φ']
exact superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ] [φ']
lemma superCommute_superCommute_ofCrAnState_bosonic_or_fermionic (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma superCommuteF_superCommuteF_ofCrAnState_bosonic_or_fermionic (φ1 φ2 φ3 : 𝓕.CrAnStates) :
[ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca ∈ statisticSubmodule bosonic ∨
[ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca ∈ statisticSubmodule fermionic := by
rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ2 φ3 with hs | hs
rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ2 φ3 with hs | hs
<;> rcases ofCrAnState_bosonic_or_fermionic φ1 with h1 | h1
· left
have h : bosonic = bosonic + bosonic := by
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade h1 hs
apply superCommuteF_grade h1 hs
· right
have h : fermionic = fermionic + bosonic := by
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade h1 hs
apply superCommuteF_grade h1 hs
· right
have h : fermionic = bosonic + fermionic := by
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade h1 hs
apply superCommuteF_grade h1 hs
· left
have h : bosonic = fermionic + fermionic := by
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h]
apply superCommute_grade h1 hs
apply superCommuteF_grade h1 hs
lemma superCommute_bosonic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List 𝓕.CrAnStates)
lemma superCommuteF_bosonic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List 𝓕.CrAnStates)
(ha : a ∈ statisticSubmodule bosonic) :
[a, ofCrAnList φs]ₛca = ∑ (n : Fin φs.length),
ofCrAnList (φs.take n) * [a, ofCrAnState (φs.get n)]ₛca *
@ -796,7 +793,7 @@ lemma superCommute_bosonic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List
· intro a ha
obtain ⟨φs, rfl, hφs⟩ := ha
simp only [List.get_eq_getElem, p]
rw [superCommute_ofCrAnList_ofCrAnList_eq_sum]
rw [superCommuteF_ofCrAnList_ofCrAnList_eq_sum]
congr
funext n
simp [hφs]
@ -811,7 +808,7 @@ lemma superCommute_bosonic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List
simp_all [p, Finset.smul_sum]
· exact ha
lemma superCommute_fermionic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List 𝓕.CrAnStates)
lemma superCommuteF_fermionic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : List 𝓕.CrAnStates)
(ha : a ∈ statisticSubmodule fermionic) :
[a, ofCrAnList φs]ₛca = ∑ (n : Fin φs.length), 𝓢(fermionic, 𝓕 |>ₛ φs.take n) •
ofCrAnList (φs.take n) * [a, ofCrAnState (φs.get n)]ₛca *
@ -825,7 +822,7 @@ lemma superCommute_fermionic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : Lis
· intro a ha
obtain ⟨φs, rfl, hφs⟩ := ha
simp only [instCommGroup, List.get_eq_getElem, Algebra.smul_mul_assoc, p]
rw [superCommute_ofCrAnList_ofCrAnList_eq_sum]
rw [superCommuteF_ofCrAnList_ofCrAnList_eq_sum]
congr
funext n
simp [hφs]
@ -845,7 +842,7 @@ lemma superCommute_fermionic_ofCrAnList_eq_sum (a : 𝓕.CrAnAlgebra) (φs : Lis
simp [smul_smul, mul_comm]
· exact ha
lemma statistic_neq_of_superCommute_fermionic {φs φs' : List 𝓕.CrAnStates}
lemma statistic_neq_of_superCommuteF_fermionic {φs φs' : List 𝓕.CrAnStates}
(h : [ofCrAnList φs, ofCrAnList φs']ₛca ∈ statisticSubmodule fermionic) :
(𝓕 |>ₛ φs) ≠ (𝓕 |>ₛ φs') ∨ [ofCrAnList φs, ofCrAnList φs']ₛca = 0 := by
by_cases h0 : [ofCrAnList φs, ofCrAnList φs']ₛca = 0
@ -858,7 +855,7 @@ lemma statistic_neq_of_superCommute_fermionic {φs φs' : List 𝓕.CrAnStates}
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h1]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _ hc
apply ofCrAnList_mem_statisticSubmodule_of _ _
rw [← hn, hc]
@ -866,7 +863,7 @@ lemma statistic_neq_of_superCommute_fermionic {φs φs' : List 𝓕.CrAnStates}
simp only [add_eq_mul, instCommGroup, mul_self]
rfl
rw [h1]
apply superCommute_grade
apply superCommuteF_grade
apply ofCrAnList_mem_statisticSubmodule_of _ _
simpa using hc
apply ofCrAnList_mem_statisticSubmodule_of _ _

142
HepLean/PerturbationTheory/Algebras/CrAnAlgebra/TimeOrder.lean
View file

@ -27,19 +27,19 @@ open HepLean.List
-/
/-- Time ordering for the `CrAnAlgebra`. -/
def timeOrder : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 :=
def timeOrderF : CrAnAlgebra 𝓕 →ₗ[ℂ] CrAnAlgebra 𝓕 :=
Basis.constr ofCrAnListBasis ℂ fun φs =>
crAnTimeOrderSign φs • ofCrAnList (crAnTimeOrderList φs)
@[inherit_doc timeOrder]
scoped[FieldSpecification.CrAnAlgebra] notation "𝓣ᶠ(" a ")" => timeOrder a
@[inherit_doc timeOrderF]
scoped[FieldSpecification.CrAnAlgebra] notation "𝓣ᶠ(" a ")" => timeOrderF a
lemma timeOrder_ofCrAnList (φs : List 𝓕.CrAnStates) :
lemma timeOrderF_ofCrAnList (φs : List 𝓕.CrAnStates) :
𝓣ᶠ(ofCrAnList φs) = crAnTimeOrderSign φs • ofCrAnList (crAnTimeOrderList φs) := by
rw [← ofListBasis_eq_ofList]
simp only [timeOrder, Basis.constr_basis]
simp only [timeOrderF, Basis.constr_basis]
lemma timeOrder_timeOrder_mid (a b c : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b * c) = 𝓣ᶠ(a * 𝓣ᶠ(b) * c) := by
lemma timeOrderF_timeOrderF_mid (a b c : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b * c) = 𝓣ᶠ(a * 𝓣ᶠ(b) * c) := by
let pc (c : 𝓕.CrAnAlgebra) (hc : c ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
Prop := 𝓣ᶠ(a * b * c) = 𝓣ᶠ(a * 𝓣ᶠ(b) * c)
change pc c (Basis.mem_span _ c)
@ -61,10 +61,10 @@ lemma timeOrder_timeOrder_mid (a b c : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b * c) =
· intro x hx
obtain ⟨φs'', rfl⟩ := hx
simp only [ofListBasis_eq_ofList, pa]
rw [timeOrder_ofCrAnList]
rw [timeOrderF_ofCrAnList]
simp only [← ofCrAnList_append, Algebra.mul_smul_comm,
Algebra.smul_mul_assoc, map_smul]
rw [timeOrder_ofCrAnList, timeOrder_ofCrAnList, smul_smul]
rw [timeOrderF_ofCrAnList, timeOrderF_ofCrAnList, smul_smul]
congr 1
· simp only [crAnTimeOrderSign, crAnTimeOrderList]
rw [Wick.koszulSign_of_append_eq_insertionSort, mul_comm]
@ -87,68 +87,70 @@ lemma timeOrder_timeOrder_mid (a b c : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b * c) =
· intro x hx h hp
simp_all [pc]
lemma timeOrder_timeOrder_right (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(a * 𝓣ᶠ(b)) := by
lemma timeOrderF_timeOrderF_right (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(a * 𝓣ᶠ(b)) := by
trans 𝓣ᶠ(a * b * 1)
· simp
· rw [timeOrder_timeOrder_mid]
· rw [timeOrderF_timeOrderF_mid]
simp
lemma timeOrder_timeOrder_left (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(𝓣ᶠ(a) * b) := by
lemma timeOrderF_timeOrderF_left (a b : 𝓕.CrAnAlgebra) : 𝓣ᶠ(a * b) = 𝓣ᶠ(𝓣ᶠ(a) * b) := by
trans 𝓣ᶠ(1 * a * b)
· simp
· rw [timeOrder_timeOrder_mid]
· rw [timeOrderF_timeOrderF_mid]
simp
lemma timeOrder_ofStateList (φs : List 𝓕.States) :
lemma timeOrderF_ofStateList (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList φs) = timeOrderSign φs • ofStateList (timeOrderList φs) := by
conv_lhs =>
rw [ofStateList_sum, map_sum]
enter [2, x]
rw [timeOrder_ofCrAnList]
rw [timeOrderF_ofCrAnList]
simp only [crAnTimeOrderSign_crAnSection]
rw [← Finset.smul_sum]
congr
rw [ofStateList_sum, sum_crAnSections_timeOrder]
rfl
lemma timeOrder_ofStateList_nil : timeOrder (𝓕 := 𝓕) (ofStateList []) = 1 := by
rw [timeOrder_ofStateList]
lemma timeOrderF_ofStateList_nil : timeOrderF (𝓕 := 𝓕) (ofStateList []) = 1 := by
rw [timeOrderF_ofStateList]
simp [timeOrderSign, Wick.koszulSign, timeOrderList]
@[simp]
lemma timeOrder_ofStateList_singleton (φ : 𝓕.States) : 𝓣ᶠ(ofStateList [φ]) = ofStateList [φ] := by
simp [timeOrder_ofStateList, timeOrderSign, timeOrderList]
lemma timeOrderF_ofStateList_singleton (φ : 𝓕.States) : 𝓣ᶠ(ofStateList [φ]) = ofStateList [φ] := by
simp [timeOrderF_ofStateList, timeOrderSign, timeOrderList]
lemma timeOrder_ofState_ofState_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
lemma timeOrderF_ofState_ofState_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
𝓣ᶠ(ofState φ * ofState ψ) = ofState φ * ofState ψ := by
rw [← ofStateList_singleton, ← ofStateList_singleton, ← ofStateList_append, timeOrder_ofStateList]
rw [← ofStateList_singleton, ← ofStateList_singleton, ← ofStateList_append,
timeOrderF_ofStateList]
simp only [List.singleton_append]
rw [timeOrderSign_pair_ordered h, timeOrderList_pair_ordered h]
simp
lemma timeOrder_ofState_ofState_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
lemma timeOrderF_ofState_ofState_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
𝓣ᶠ(ofState φ * ofState ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • ofState ψ * ofState φ := by
rw [← ofStateList_singleton, ← ofStateList_singleton,
← ofStateList_append, timeOrder_ofStateList]
← ofStateList_append, timeOrderF_ofStateList]
simp only [List.singleton_append, instCommGroup.eq_1, Algebra.smul_mul_assoc]
rw [timeOrderSign_pair_not_ordered h, timeOrderList_pair_not_ordered h]
simp [← ofStateList_append]
lemma timeOrder_ofState_ofState_not_ordered_eq_timeOrder {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
lemma timeOrderF_ofState_ofState_not_ordered_eq_timeOrderF {φ ψ : 𝓕.States}
(h : ¬ timeOrderRel φ ψ) :
𝓣ᶠ(ofState φ * ofState ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • 𝓣ᶠ(ofState ψ * ofState φ) := by
rw [timeOrder_ofState_ofState_not_ordered h]
rw [timeOrder_ofState_ofState_ordered]
rw [timeOrderF_ofState_ofState_not_ordered h]
rw [timeOrderF_ofState_ofState_ordered]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc]
have hx := IsTotal.total (r := timeOrderRel) ψ φ
simp_all
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel
lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) :
𝓣ᶠ([ofCrAnState φ, ofCrAnState ψ]ₛca) = 0 := by
rw [superCommute_ofCrAnState_ofCrAnState]
rw [superCommuteF_ofCrAnState_ofCrAnState]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, map_sub, map_smul]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton,
← ofCrAnList_append, ← ofCrAnList_append, timeOrder_ofCrAnList, timeOrder_ofCrAnList]
← ofCrAnList_append, ← ofCrAnList_append, timeOrderF_ofCrAnList, timeOrderF_ofCrAnList]
simp only [List.singleton_append]
rw [crAnTimeOrderSign_pair_not_ordered h, crAnTimeOrderList_pair_not_ordered h]
rw [sub_eq_zero, smul_smul]
@ -160,51 +162,51 @@ lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel
· rw [crAnTimeOrderList_pair_ordered]
simp_all
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right
lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.CrAnAlgebra) :
𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca) = 0 := by
rw [timeOrder_timeOrder_right,
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
rw [timeOrderF_timeOrderF_right,
timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
simp
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left
lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a : 𝓕.CrAnAlgebra) :
𝓣ᶠ([ofCrAnState φ, ofCrAnState ψ]ₛca * a) = 0 := by
rw [timeOrder_timeOrder_left,
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
rw [timeOrderF_timeOrderF_left,
timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
simp
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_mid
lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_mid
{φ ψ : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ ψ) (a b : 𝓕.CrAnAlgebra) :
𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) = 0 := by
rw [timeOrder_timeOrder_mid,
timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
rw [timeOrderF_timeOrderF_mid,
timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel h]
simp
lemma timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel
lemma timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel
{φ1 φ2 : 𝓕.CrAnStates} (h : ¬ crAnTimeOrderRel φ1 φ2) (a : 𝓕.CrAnAlgebra) :
𝓣ᶠ([a, [ofCrAnState φ1, ofCrAnState φ2]ₛca]ₛca) = 0 := by
rw [← bosonicProj_add_fermionicProj a]
simp only [map_add, LinearMap.add_apply]
rw [bosonic_superCommute (Submodule.coe_mem (bosonicProj a))]
rw [bosonic_superCommuteF (Submodule.coe_mem (bosonicProj a))]
simp only [map_sub]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
simp only [sub_self, zero_add]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton]
rcases superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h' | h'
· rw [superCommute_bonsonic h']
rcases superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h' | h'
· rw [superCommuteF_bonsonic h']
simp only [ofCrAnList_singleton, map_sub]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
simp
· rw [superCommute_fermionic_fermionic (Submodule.coe_mem (fermionicProj a)) h']
· rw [superCommuteF_fermionic_fermionic (Submodule.coe_mem (fermionicProj a)) h']
simp only [ofCrAnList_singleton, map_add]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_left h]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel_right h]
simp
lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel
lemma timeOrderF_superCommuteF_ofCrAnState_superCommuteF_not_crAnTimeOrderRel
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ1 φ2)
(h13 : ¬ crAnTimeOrderRel φ1 φ3) :
𝓣ᶠ([ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca) = 0 := by
@ -213,14 +215,14 @@ lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel
simp only [instCommGroup.eq_1, ofList_singleton, ofCrAnList_singleton, neg_smul, map_smul,
map_sub, map_neg, smul_eq_zero]
right
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h12]
rw [superCommute_ofCrAnState_ofCrAnState_symm φ3]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h12]
rw [superCommuteF_ofCrAnState_ofCrAnState_symm φ3]
simp only [smul_zero, neg_zero, instCommGroup.eq_1, neg_smul, map_neg, map_smul, smul_neg,
sub_neg_eq_add, zero_add, smul_eq_zero]
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h13]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h13]
simp
lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel'
lemma timeOrderF_superCommuteF_ofCrAnState_superCommuteF_not_crAnTimeOrderRel'
{φ1 φ2 φ3 : 𝓕.CrAnStates} (h12 : ¬ crAnTimeOrderRel φ2 φ1)
(h13 : ¬ crAnTimeOrderRel φ3 φ1) :
𝓣ᶠ([ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca) = 0 := by
@ -229,14 +231,14 @@ lemma timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel'
simp only [instCommGroup.eq_1, ofList_singleton, ofCrAnList_singleton, neg_smul, map_smul,
map_sub, map_neg, smul_eq_zero]
right
rw [superCommute_ofCrAnState_ofCrAnState_symm φ1]
rw [superCommuteF_ofCrAnState_ofCrAnState_symm φ1]
simp only [instCommGroup.eq_1, neg_smul, map_neg, map_smul, smul_neg, neg_neg]
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h12]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h12]
simp only [smul_zero, zero_sub, neg_eq_zero, smul_eq_zero]
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h13]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h13]
simp
lemma timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel
lemma timeOrderF_superCommuteF_ofCrAnState_superCommuteF_all_not_crAnTimeOrderRel
(φ1 φ2 φ3 : 𝓕.CrAnStates) (h : ¬
(crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
@ -245,13 +247,13 @@ lemma timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel
simp only [not_and] at h
by_cases h23 : ¬ crAnTimeOrderRel φ2 φ3
· simp_all only [IsEmpty.forall_iff, implies_true]
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h23]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h23]
simp_all only [Decidable.not_not, forall_const]
by_cases h32 : ¬ crAnTimeOrderRel φ3 φ2
· simp_all only [not_false_eq_true, implies_true]
rw [superCommute_ofCrAnState_ofCrAnState_symm]
rw [superCommuteF_ofCrAnState_ofCrAnState_symm]
simp only [instCommGroup.eq_1, neg_smul, map_neg, map_smul, neg_eq_zero, smul_eq_zero]
rw [timeOrder_superCommute_superCommute_ofCrAnState_not_crAnTimeOrderRel h32]
rw [timeOrderF_superCommuteF_superCommuteF_ofCrAnState_not_crAnTimeOrderRel h32]
simp
simp_all only [imp_false, Decidable.not_not]
by_cases h12 : ¬ crAnTimeOrderRel φ1 φ2
@ -259,7 +261,7 @@ lemma timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel
intro h13
apply h12
exact IsTrans.trans φ1 φ3 φ2 h13 h32
rw [timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel h12 h13]
rw [timeOrderF_superCommuteF_ofCrAnState_superCommuteF_not_crAnTimeOrderRel h12 h13]
simp_all only [Decidable.not_not, forall_const]
have h13 : crAnTimeOrderRel φ1 φ3 := IsTrans.trans φ1 φ2 φ3 h12 h23
simp_all only [forall_const]
@ -269,18 +271,18 @@ lemma timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel
intro h31
apply h21
exact IsTrans.trans φ2 φ3 φ1 h23 h31
rw [timeOrder_superCommute_ofCrAnState_superCommute_not_crAnTimeOrderRel' h21 h31]
rw [timeOrderF_superCommuteF_ofCrAnState_superCommuteF_not_crAnTimeOrderRel' h21 h31]
simp_all only [Decidable.not_not, forall_const]
refine False.elim (h ?_)
exact IsTrans.trans φ3 φ2 φ1 h32 h21
lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_eq_time
lemma timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_eq_time
{φ ψ : 𝓕.CrAnStates} (h1 : crAnTimeOrderRel φ ψ) (h2 : crAnTimeOrderRel ψ φ) :
𝓣ᶠ([ofCrAnState φ, ofCrAnState ψ]ₛca) = [ofCrAnState φ, ofCrAnState ψ]ₛca := by
rw [superCommute_ofCrAnState_ofCrAnState]
rw [superCommuteF_ofCrAnState_ofCrAnState]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, map_sub, map_smul]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton,
← ofCrAnList_append, ← ofCrAnList_append, timeOrder_ofCrAnList, timeOrder_ofCrAnList]
← ofCrAnList_append, ← ofCrAnList_append, timeOrderF_ofCrAnList, timeOrderF_ofCrAnList]
simp only [List.singleton_append]
rw [crAnTimeOrderSign_pair_ordered h1, crAnTimeOrderList_pair_ordered h1,
crAnTimeOrderSign_pair_ordered h2, crAnTimeOrderList_pair_ordered h2]
@ -295,12 +297,12 @@ lemma timeOrder_superCommute_ofCrAnState_ofCrAnState_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 timeOrder_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma timeOrderF_eq_maxTimeField_mul (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList (φ :: φs)) =
𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ (φ :: φs).take (maxTimeFieldPos φ φs)) •
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofStateList (eraseMaxTimeField φ φs)) := by
rw [timeOrder_ofStateList, timeOrderList_eq_maxTimeField_timeOrderList]
rw [ofStateList_cons, timeOrder_ofStateList]
rw [timeOrderF_ofStateList, timeOrderList_eq_maxTimeField_timeOrderList]
rw [ofStateList_cons, timeOrderF_ofStateList]
simp only [instCommGroup.eq_1, Algebra.mul_smul_comm, Algebra.smul_mul_assoc, smul_smul]
congr
rw [timerOrderSign_of_eraseMaxTimeField, mul_assoc]
@ -310,12 +312,12 @@ lemma timeOrder_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 timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
lemma timeOrderF_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣ᶠ(ofStateList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
(Finset.filter (fun x =>
(maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs) Finset.univ)⟩) •
ofState (maxTimeField φ φs) * 𝓣ᶠ(ofStateList (eraseMaxTimeField φ φs)) := by
rw [timeOrder_eq_maxTimeField_mul]
rw [timeOrderF_eq_maxTimeField_mul]
congr 3
apply FieldStatistic.ofList_perm
nth_rewrite 1 [← List.finRange_map_get (φ :: φs)]

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

@ -72,7 +72,7 @@ lemma ι_of_mem_fieldOpIdealSet (x : CrAnAlgebra 𝓕) (hx : x ∈ 𝓕.fieldOpI
refine RingConGen.Rel.of x 0 ?_
simpa using hx
lemma ι_superCommute_of_create_create (φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = .create)
lemma ι_superCommuteF_of_create_create (φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = .create)
(hφc' : 𝓕 |>ᶜ φc' = .create) : ι [ofCrAnState φc, ofCrAnState φc']ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
simp only [fieldOpIdealSet, exists_and_left, Set.mem_setOf_eq]
@ -81,7 +81,7 @@ lemma ι_superCommute_of_create_create (φc φc' : 𝓕.CrAnStates) (hφc : 𝓕
left
use φc, φc', hφc, hφc'
lemma ι_superCommute_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
lemma ι_superCommuteF_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
(hφa : 𝓕 |>ᶜ φa = .annihilate) (hφa' : 𝓕 |>ᶜ φa' = .annihilate) :
ι [ofCrAnState φa, ofCrAnState φa']ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
@ -92,7 +92,7 @@ lemma ι_superCommute_of_annihilate_annihilate (φa φa' : 𝓕.CrAnStates)
left
use φa, φa', hφa, hφa'
lemma ι_superCommute_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
lemma ι_superCommuteF_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : ι [ofCrAnState φ, ofCrAnState ψ]ₛca = 0 := by
apply ι_of_mem_fieldOpIdealSet
simp only [fieldOpIdealSet, exists_prop, exists_and_left, Set.mem_setOf_eq]
@ -101,24 +101,24 @@ lemma ι_superCommute_of_diff_statistic {φ ψ : 𝓕.CrAnStates}
right
use φ, ψ
lemma ι_superCommute_zero_of_fermionic (φ ψ : 𝓕.CrAnStates)
lemma ι_superCommuteF_zero_of_fermionic (φ ψ : 𝓕.CrAnStates)
(h : [ofCrAnState φ, ofCrAnState ψ]ₛca ∈ statisticSubmodule fermionic) :
ι [ofCrAnState φ, ofCrAnState ψ]ₛca = 0 := by
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton] at h ⊢
rcases statistic_neq_of_superCommute_fermionic h with h | h
rcases statistic_neq_of_superCommuteF_fermionic h with h | h
· simp only [ofCrAnList_singleton]
apply ι_superCommute_of_diff_statistic
apply ι_superCommuteF_of_diff_statistic
simpa using h
· simp [h]
lemma ι_superCommute_ofCrAnState_ofCrAnState_bosonic_or_zero (φ ψ : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_zero (φ ψ : 𝓕.CrAnStates) :
[ofCrAnState φ, ofCrAnState ψ]ₛca ∈ statisticSubmodule bosonic ∨
ι [ofCrAnState φ, ofCrAnState ψ]ₛca = 0 := by
rcases superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ] [ψ] with h | h
rcases superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ] [ψ] with h | h
· simp_all [ofCrAnList_singleton]
· simp_all only [ofCrAnList_singleton]
right
exact ι_superCommute_zero_of_fermionic _ _ h
exact ι_superCommuteF_zero_of_fermionic _ _ h
/-!
@ -127,63 +127,63 @@ lemma ι_superCommute_ofCrAnState_ofCrAnState_bosonic_or_zero (φ ψ : 𝓕.CrAn
-/
@[simp]
lemma ι_superCommute_ofCrAnState_superCommute_ofCrAnState_ofCrAnState (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnState_superCommuteF_ofCrAnState_ofCrAnState (φ1 φ2 φ3 : 𝓕.CrAnStates) :
ι [ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ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 ι_superCommute_superCommute_ofCrAnState_ofCrAnState_ofCrAnState (φ1 φ2 φ3 : 𝓕.CrAnStates) :
lemma ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_ofCrAnState (φ1 φ2 φ3 : 𝓕.CrAnStates) :
ι [[ofCrAnState φ1, ofCrAnState φ2]ₛca, ofCrAnState φ3]ₛca = 0 := by
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_singleton]
rcases superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h | h
· rw [bonsonic_superCommute_symm h]
rcases superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h | h
· rw [bonsonic_superCommuteF_symm h]
simp [ofCrAnList_singleton]
· rcases ofCrAnList_bosonic_or_fermionic [φ3] with h' | h'
· rw [superCommute_bonsonic_symm h']
· rw [superCommuteF_bonsonic_symm h']
simp [ofCrAnList_singleton]
· rw [superCommute_fermionic_fermionic_symm h h']
· rw [superCommuteF_fermionic_fermionic_symm h h']
simp [ofCrAnList_singleton]
lemma ι_superCommute_superCommute_ofCrAnState_ofCrAnState_ofCrAnList (φ1 φ2 : 𝓕.CrAnStates)
lemma ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_ofCrAnList (φ1 φ2 : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) :
ι [[ofCrAnState φ1, ofCrAnState φ2]ₛca, ofCrAnList φs]ₛca = 0 := by
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton]
rcases superCommute_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h | h
· rw [superCommute_bosonic_ofCrAnList_eq_sum _ _ h]
simp [ofCrAnList_singleton, ι_superCommute_superCommute_ofCrAnState_ofCrAnState_ofCrAnState]
· rw [superCommute_fermionic_ofCrAnList_eq_sum _ _ h]
simp [ofCrAnList_singleton, ι_superCommute_superCommute_ofCrAnState_ofCrAnState_ofCrAnState]
rcases superCommuteF_ofCrAnList_ofCrAnList_bosonic_or_fermionic [φ1] [φ2] with h | h
· rw [superCommuteF_bosonic_ofCrAnList_eq_sum _ _ h]
simp [ofCrAnList_singleton, ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_ofCrAnState]
· rw [superCommuteF_fermionic_ofCrAnList_eq_sum _ _ h]
simp [ofCrAnList_singleton, ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_ofCrAnState]
@[simp]
lemma ι_superCommute_superCommute_ofCrAnState_ofCrAnState_crAnAlgebra (φ1 φ2 : 𝓕.CrAnStates)
lemma ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_crAnAlgebra (φ1 φ2 : 𝓕.CrAnStates)
(a : 𝓕.CrAnAlgebra) : ι [[ofCrAnState φ1, ofCrAnState φ2]ₛca, a]ₛca = 0 := by
change (ι.toLinearMap ∘ₗ superCommute [ofCrAnState φ1, ofCrAnState φ2]ₛca) a = _
have h1 : (ι.toLinearMap ∘ₗ superCommute [ofCrAnState φ1, ofCrAnState φ2]ₛca) = 0 := by
change (ι.toLinearMap ∘ₗ superCommuteF [ofCrAnState φ1, ofCrAnState φ2]ₛca) a = _
have h1 : (ι.toLinearMap ∘ₗ superCommuteF [ofCrAnState φ1, ofCrAnState φ2]ₛca) = 0 := by
apply (ofCrAnListBasis.ext fun l ↦ ?_)
simp [ι_superCommute_superCommute_ofCrAnState_ofCrAnState_ofCrAnList]
simp [ι_superCommuteF_superCommuteF_ofCrAnState_ofCrAnState_ofCrAnList]
rw [h1]
simp
lemma ι_commute_crAnAlgebra_superCommute_ofCrAnState_ofCrAnState (φ1 φ2 : 𝓕.CrAnStates)
lemma ι_commute_crAnAlgebra_superCommuteF_ofCrAnState_ofCrAnState (φ1 φ2 : 𝓕.CrAnStates)
(a : 𝓕.CrAnAlgebra) : ι a * ι [ofCrAnState φ1, ofCrAnState φ2]ₛca -
ι [ofCrAnState φ1, ofCrAnState φ2]ₛca * ι a = 0 := by
rcases ι_superCommute_ofCrAnState_ofCrAnState_bosonic_or_zero φ1 φ2 with h | h
rcases ι_superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_zero φ1 φ2 with h | h
swap
· simp [h]
trans - ι [[ofCrAnState φ1, ofCrAnState φ2]ₛca, a]ₛca
· rw [bosonic_superCommute h]
· rw [bosonic_superCommuteF h]
simp
· simp
lemma ι_superCommute_ofCrAnState_ofCrAnState_mem_center (φ ψ : 𝓕.CrAnStates) :
lemma ι_superCommuteF_ofCrAnState_ofCrAnState_mem_center (φ ψ : 𝓕.CrAnStates) :
ι [ofCrAnState φ, ofCrAnState ψ]ₛca ∈ Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
rw [Subalgebra.mem_center_iff]
intro a
obtain ⟨a, rfl⟩ := ι_surjective a
have h0 := ι_commute_crAnAlgebra_superCommute_ofCrAnState_ofCrAnState φ ψ a
trans ι ((superCommute (ofCrAnState φ)) (ofCrAnState ψ)) * ι a + 0
have h0 := ι_commute_crAnAlgebra_superCommuteF_ofCrAnState_ofCrAnState φ ψ a
trans ι ((superCommuteF (ofCrAnState φ)) (ofCrAnState ψ)) * ι a + 0
swap
simp only [add_zero]
rw [← h0]
@ -209,25 +209,25 @@ lemma bosonicProj_mem_fieldOpIdealSet_or_zero (x : CrAnAlgebra 𝓕) (hx : x ∈
simp only [fieldOpIdealSet, exists_prop, Set.mem_setOf_eq] at hx
rcases hx with ⟨φ1, φ2, φ3, rfl⟩ | ⟨φc, φc', hφc, hφc', rfl⟩ | ⟨φa, φa', hφa, hφa', rfl⟩ |
⟨φ, φ', hdiff, rfl⟩
· rcases superCommute_superCommute_ofCrAnState_bosonic_or_fermionic φ1 φ2 φ3 with h | h
· rcases superCommuteF_superCommuteF_ofCrAnState_bosonic_or_fermionic φ1 φ2 φ3 with h | h
· left
rw [bosonicProj_of_mem_bosonic _ h]
simpa using hx'
· right
rw [bosonicProj_of_mem_fermionic _ h]
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φc φc' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φc φc' with h | h
· left
rw [bosonicProj_of_mem_bosonic _ h]
simpa using hx'
· right
rw [bosonicProj_of_mem_fermionic _ h]
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φa φa' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φa φa' with h | h
· left
rw [bosonicProj_of_mem_bosonic _ h]
simpa using hx'
· right
rw [bosonicProj_of_mem_fermionic _ h]
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ φ' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ φ' with h | h
· left
rw [bosonicProj_of_mem_bosonic _ h]
simpa using hx'
@ -240,25 +240,25 @@ lemma fermionicProj_mem_fieldOpIdealSet_or_zero (x : CrAnAlgebra 𝓕) (hx : x
simp only [fieldOpIdealSet, exists_prop, Set.mem_setOf_eq] at hx
rcases hx with ⟨φ1, φ2, φ3, rfl⟩ | ⟨φc, φc', hφc, hφc', rfl⟩ | ⟨φa, φa', hφa, hφa', rfl⟩ |
⟨φ, φ', hdiff, rfl⟩
· rcases superCommute_superCommute_ofCrAnState_bosonic_or_fermionic φ1 φ2 φ3 with h | h
· rcases superCommuteF_superCommuteF_ofCrAnState_bosonic_or_fermionic φ1 φ2 φ3 with h | h
· right
rw [fermionicProj_of_mem_bosonic _ h]
· left
rw [fermionicProj_of_mem_fermionic _ h]
simpa using hx'
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φc φc' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φc φc' with h | h
· right
rw [fermionicProj_of_mem_bosonic _ h]
· left
rw [fermionicProj_of_mem_fermionic _ h]
simpa using hx'
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φa φa' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φa φa' with h | h
· right
rw [fermionicProj_of_mem_bosonic _ h]
· left
rw [fermionicProj_of_mem_fermionic _ h]
simpa using hx'
· rcases superCommute_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ φ' with h | h
· rcases superCommuteF_ofCrAnState_ofCrAnState_bosonic_or_fermionic φ φ' with h | h
· right
rw [fermionicProj_of_mem_bosonic _ h]
· left
@ -396,8 +396,8 @@ lemma bosonicProj_mem_ideal (x : CrAnAlgebra 𝓕) (hx : x ∈ TwoSidedIdeal.spa
· intro x y hx hy hpx hpy
simp_all only [map_add, Submodule.coe_add, p]
apply TwoSidedIdeal.add_mem
exact hpx
exact hpy
· exact hpx
· exact hpy
· intro x hx
simp [p]
@ -413,7 +413,7 @@ lemma ι_eq_zero_iff_ι_bosonicProj_fermonicProj_zero (x : CrAnAlgebra 𝓕) :
ι x = 0 ↔ ι x.bosonicProj.1 = 0 ∧ ι x.fermionicProj.1 = 0 := by
apply Iff.intro
· intro h
rw [@ι_eq_zero_iff_mem_ideal] at h ⊢
rw [ι_eq_zero_iff_mem_ideal] at h ⊢
rw [ι_eq_zero_iff_mem_ideal]
apply And.intro
· exact bosonicProj_mem_ideal x h
@ -422,5 +422,113 @@ lemma ι_eq_zero_iff_ι_bosonicProj_fermonicProj_zero (x : CrAnAlgebra 𝓕) :
rw [← bosonicProj_add_fermionicProj x]
simp_all
/-!
## Constructors
-/
/-- An element of `FieldOpAlgebra` from a `States`. -/
def ofFieldOp (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofState φ)
lemma ofFieldOp_eq_ι_ofState (φ : 𝓕.States) : ofFieldOp φ = ι (ofState φ) := rfl
/-- An element of `FieldOpAlgebra` from a list of `States`. -/
def ofFieldOpList (φs : List 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofStateList φs)
lemma ofFieldOpList_eq_ι_ofStateList (φs : List 𝓕.States) :
ofFieldOpList φs = ι (ofStateList φs) := rfl
lemma ofFieldOpList_append (φs ψs : List 𝓕.States) :
ofFieldOpList (φs ++ ψs) = ofFieldOpList φs * ofFieldOpList ψs := by
simp only [ofFieldOpList]
rw [ofStateList_append]
simp
lemma ofFieldOpList_singleton (φ : 𝓕.States) :
ofFieldOpList [φ] = ofFieldOp φ := by
simp only [ofFieldOpList, ofFieldOp, ofStateList_singleton]
/-- An element of `FieldOpAlgebra` from a `CrAnStates`. -/
def ofCrAnFieldOp (φ : 𝓕.CrAnStates) : 𝓕.FieldOpAlgebra := ι (ofCrAnState φ)
lemma ofCrAnFieldOp_eq_ι_ofCrAnState (φ : 𝓕.CrAnStates) :
ofCrAnFieldOp φ = ι (ofCrAnState φ) := rfl
lemma ofFieldOp_eq_sum (φ : 𝓕.States) :
ofFieldOp φ = (∑ i : 𝓕.statesToCrAnType φ, ofCrAnFieldOp ⟨φ, i⟩) := by
rw [ofFieldOp, ofState]
simp only [map_sum]
rfl
/-- An element of `FieldOpAlgebra` from a list of `CrAnStates`. -/
def ofCrAnFieldOpList (φs : List 𝓕.CrAnStates) : 𝓕.FieldOpAlgebra := ι (ofCrAnList φs)
lemma ofCrAnFieldOpList_eq_ι_ofCrAnList (φs : List 𝓕.CrAnStates) :
ofCrAnFieldOpList φs = ι (ofCrAnList φs) := rfl
lemma ofCrAnFieldOpList_append (φs ψs : List 𝓕.CrAnStates) :
ofCrAnFieldOpList (φs ++ ψs) = ofCrAnFieldOpList φs * ofCrAnFieldOpList ψs := by
simp only [ofCrAnFieldOpList]
rw [ofCrAnList_append]
simp
lemma ofCrAnFieldOpList_singleton (φ : 𝓕.CrAnStates) :
ofCrAnFieldOpList [φ] = ofCrAnFieldOp φ := by
simp only [ofCrAnFieldOpList, ofCrAnFieldOp, ofCrAnList_singleton]
lemma ofFieldOpList_eq_sum (φs : List 𝓕.States) :
ofFieldOpList φs = ∑ s : CrAnSection φs, ofCrAnFieldOpList s.1 := by
rw [ofFieldOpList, ofStateList_sum]
simp only [map_sum]
rfl
/-- The annihilation part of a state. -/
def anPart (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (anPartF φ)
lemma anPart_eq_ι_anPartF (φ : 𝓕.States) : anPart φ = ι (anPartF φ) := rfl
@[simp]
lemma anPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
anPart (States.inAsymp φ) = 0 := by
simp [anPart, anPartF]
@[simp]
lemma anPart_position (φ : 𝓕.PositionStates) :
anPart (States.position φ) =
ofCrAnFieldOp ⟨States.position φ, CreateAnnihilate.annihilate⟩ := by
simp [anPart, ofCrAnFieldOp]
@[simp]
lemma anPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
anPart (States.outAsymp φ) = ofCrAnFieldOp ⟨States.outAsymp φ, ()⟩ := by
simp [anPart, ofCrAnFieldOp]
/-- The creation part of a state. -/
def crPart (φ : 𝓕.States) : 𝓕.FieldOpAlgebra := ι (crPartF φ)
lemma crPart_eq_ι_crPartF (φ : 𝓕.States) : crPart φ = ι (crPartF φ) := rfl
@[simp]
lemma crPart_negAsymp (φ : 𝓕.IncomingAsymptotic) :
crPart (States.inAsymp φ) = ofCrAnFieldOp ⟨States.inAsymp φ, ()⟩ := by
simp [crPart, ofCrAnFieldOp]
@[simp]
lemma crPart_position (φ : 𝓕.PositionStates) :
crPart (States.position φ) =
ofCrAnFieldOp ⟨States.position φ, CreateAnnihilate.create⟩ := by
simp [crPart, ofCrAnFieldOp]
@[simp]
lemma crPart_posAsymp (φ : 𝓕.OutgoingAsymptotic) :
crPart (States.outAsymp φ) = 0 := by
simp [crPart]
lemma ofFieldOp_eq_crPart_add_anPart (φ : 𝓕.States) :
ofFieldOp φ = crPart φ + anPart φ := by
rw [ofFieldOp, crPart, anPart, ofState_eq_crPartF_add_anPartF]
simp only [map_add]
end FieldOpAlgebra
end FieldSpecification

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

@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.PerturbationTheory.Algebras.CrAnAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.Basic
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.SuperCommute
/-!
# Normal Ordering on Field operator algebra
@ -24,53 +24,54 @@ variable {𝓕 : FieldSpecification}
## Normal order on super-commutators.
The main result of this is
`ι_normalOrder_superCommute_eq_zero_mul`
`ι_normalOrderF_superCommuteF_eq_zero_mul`
which states that applying `ι` to the normal order of something containing a super-commutator
is zero.
-/
lemma ι_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero
lemma ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
ι 𝓝ᶠ(ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca * ofCrAnList φ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'
· rw [normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, ι_superCommute_of_create_create φa φa' hφa hφa']
· rw [normalOrderF_superCommuteF_ofCrAnList_create_create_ofCrAnList φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, ι_superCommuteF_of_create_create φa φa' hφa hφa']
simp
· rw [normalOrder_superCommute_create_annihilate φa φa' hφa hφa' (ofCrAnList φs)
· rw [normalOrderF_superCommuteF_create_annihilate φa φa' hφa hφa' (ofCrAnList φs)
(ofCrAnList φs')]
simp
· rw [normalOrder_superCommute_annihilate_create φa' φa hφa' hφa (ofCrAnList φs)
· rw [normalOrderF_superCommuteF_annihilate_create φa' φa hφa' hφa (ofCrAnList φs)
(ofCrAnList φs')]
simp
· rw [normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList φa φa' hφa hφa' φs φs']
· rw [normalOrderF_superCommuteF_ofCrAnList_annihilate_annihilate_ofCrAnList
φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul,
ι_superCommute_of_annihilate_annihilate φa φa' hφa hφa']
ι_superCommuteF_of_annihilate_annihilate φa φa' hφa hφa']
simp
lemma ι_normalOrder_superCommute_ofCrAnList_eq_zero
lemma ι_normalOrderF_superCommuteF_ofCrAnList_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates)
(a : 𝓕.CrAnAlgebra) : ι 𝓝ᶠ(ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca * a) = 0 := by
have hf : ι.toLinearMap ∘ₗ normalOrder ∘ₗ
have hf : ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap (ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca) = 0 := by
apply ofCrAnListBasis.ext
intro l
simp only [CrAnAlgebra.ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
AlgHom.toLinearMap_apply, LinearMap.zero_apply]
exact ι_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero φa φa' φs l
change (ι.toLinearMap ∘ₗ normalOrder ∘ₗ
exact ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero φa φa' φs l
change (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap ((ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca))) a = 0
rw [hf]
simp
lemma ι_normalOrder_superCommute_ofCrAnState_eq_zero_mul (φa φa' : 𝓕.CrAnStates)
lemma ι_normalOrderF_superCommuteF_ofCrAnState_eq_zero_mul (φa φa' : 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnState φa, ofCrAnState φa']ₛca * b) = 0 := by
rw [mul_assoc]
change (ι.toLinearMap ∘ₗ normalOrder ∘ₗ mulLinearMap.flip
change (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ mulLinearMap.flip
([ofCrAnState φa, ofCrAnState φa']ₛca * b)) a = 0
have hf : ι.toLinearMap ∘ₗ normalOrder ∘ₗ mulLinearMap.flip
have hf : ι.toLinearMap ∘ₗ normalOrderF ∘ₗ mulLinearMap.flip
([ofCrAnState φa, ofCrAnState φa']ₛca * b) = 0 := by
apply ofCrAnListBasis.ext
intro l
@ -78,98 +79,98 @@ lemma ι_normalOrder_superCommute_ofCrAnState_eq_zero_mul (φa φa' : 𝓕.CrAnS
Function.comp_apply, LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk,
AlgHom.toLinearMap_apply, LinearMap.zero_apply]
rw [← mul_assoc]
exact ι_normalOrder_superCommute_ofCrAnList_eq_zero φa φa' _ _
exact ι_normalOrderF_superCommuteF_ofCrAnList_eq_zero φa φa' _ _
rw [hf]
simp
lemma ι_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul (φa : 𝓕.CrAnStates)
lemma ι_normalOrderF_superCommuteF_ofCrAnState_ofCrAnList_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnState φa, ofCrAnList φs]ₛca * b) = 0 := by
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_eq_sum]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList_eq_sum]
rw [Finset.mul_sum, Finset.sum_mul]
rw [map_sum, map_sum]
apply Fintype.sum_eq_zero
intro n
rw [← mul_assoc, ← mul_assoc]
rw [mul_assoc _ _ b, ofCrAnList_singleton]
rw [ι_normalOrder_superCommute_ofCrAnState_eq_zero_mul]
rw [ι_normalOrderF_superCommuteF_ofCrAnState_eq_zero_mul]
lemma ι_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul (φa : 𝓕.CrAnStates)
lemma ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnState_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnList φs, ofCrAnState φa]ₛca * b) = 0 := by
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_symm, ofCrAnList_singleton]
rw [← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList_symm, ofCrAnList_singleton]
simp only [FieldStatistic.instCommGroup.eq_1, FieldStatistic.ofList_singleton, mul_neg,
Algebra.mul_smul_comm, neg_mul, Algebra.smul_mul_assoc, map_neg, map_smul]
rw [ι_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul]
rw [ι_normalOrderF_superCommuteF_ofCrAnState_ofCrAnList_eq_zero_mul]
simp
lemma ι_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul
lemma ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero_mul
(φs φs' : List 𝓕.CrAnStates) (a b : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnList φs, ofCrAnList φs']ₛca * b) = 0 := by
rw [superCommute_ofCrAnList_ofCrAnList_eq_sum, Finset.mul_sum, Finset.sum_mul]
rw [superCommuteF_ofCrAnList_ofCrAnList_eq_sum, Finset.mul_sum, Finset.sum_mul]
rw [map_sum, map_sum]
apply Fintype.sum_eq_zero
intro n
rw [← mul_assoc, ← mul_assoc]
rw [mul_assoc _ _ b]
rw [ι_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul]
rw [ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnState_eq_zero_mul]
lemma ι_normalOrder_superCommute_ofCrAnList_eq_zero_mul
lemma ι_normalOrderF_superCommuteF_ofCrAnList_eq_zero_mul
(φs : List 𝓕.CrAnStates)
(a b c : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [ofCrAnList φs, c]ₛca * b) = 0 := by
change (ι.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute (ofCrAnList φs)) c = 0
have hf : (ι.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute (ofCrAnList φs)) = 0 := by
change (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF (ofCrAnList φs)) c = 0
have hf : (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF (ofCrAnList φs)) = 0 := by
apply ofCrAnListBasis.ext
intro φs'
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, CrAnAlgebra.ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
LinearMap.zero_apply]
rw [ι_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul]
rw [ι_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero_mul]
rw [hf]
simp
@[simp]
lemma ι_normalOrder_superCommute_eq_zero_mul
lemma ι_normalOrderF_superCommuteF_eq_zero_mul
(a b c d : 𝓕.CrAnAlgebra) : ι 𝓝ᶠ(a * [d, c]ₛca * b) = 0 := by
change (ι.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute.flip c) d = 0
have hf : (ι.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute.flip c) = 0 := by
change (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF.flip c) d = 0
have hf : (ι.toLinearMap ∘ₗ normalOrderF ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF.flip c) = 0 := by
apply ofCrAnListBasis.ext
intro φs
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, CrAnAlgebra.ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
LinearMap.zero_apply]
rw [ι_normalOrder_superCommute_ofCrAnList_eq_zero_mul]
rw [ι_normalOrderF_superCommuteF_ofCrAnList_eq_zero_mul]
rw [hf]
simp
@[simp]
lemma ι_normalOrder_superCommute_eq_zero_mul_right (b c d : 𝓕.CrAnAlgebra) :
lemma ι_normalOrder_superCommuteF_eq_zero_mul_right (b c d : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ([d, c]ₛca * b) = 0 := by
rw [← ι_normalOrder_superCommute_eq_zero_mul 1 b c d]
rw [← ι_normalOrderF_superCommuteF_eq_zero_mul 1 b c d]
simp
@[simp]
lemma ι_normalOrder_superCommute_eq_zero_mul_left (a c d : 𝓕.CrAnAlgebra) :
lemma ι_normalOrderF_superCommuteF_eq_zero_mul_left (a c d : 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [d, c]ₛca) = 0 := by
rw [← ι_normalOrder_superCommute_eq_zero_mul a 1 c d]
rw [← ι_normalOrderF_superCommuteF_eq_zero_mul a 1 c d]
simp
@[simp]
lemma ι_normalOrder_superCommute_eq_zero_mul_mul_right (a b1 b2 c d: 𝓕.CrAnAlgebra) :
lemma ι_normalOrderF_superCommuteF_eq_zero_mul_mul_right (a b1 b2 c d: 𝓕.CrAnAlgebra) :
ι 𝓝ᶠ(a * [d, c]ₛca * b1 * b2) = 0 := by
rw [← ι_normalOrder_superCommute_eq_zero_mul a (b1 * b2) c d]
rw [← ι_normalOrderF_superCommuteF_eq_zero_mul a (b1 * b2) c d]
congr 2
noncomm_ring
@[simp]
lemma ι_normalOrder_superCommute_eq_zero (c d : 𝓕.CrAnAlgebra) : ι 𝓝ᶠ([d, c]ₛca) = 0 := by
rw [← ι_normalOrder_superCommute_eq_zero_mul 1 1 c d]
lemma ι_normalOrderF_superCommuteF_eq_zero (c d : 𝓕.CrAnAlgebra) : ι 𝓝ᶠ([d, c]ₛca) = 0 := by
rw [← ι_normalOrderF_superCommuteF_eq_zero_mul 1 1 c d]
simp
/-!
@ -178,7 +179,7 @@ lemma ι_normalOrder_superCommute_eq_zero (c d : 𝓕.CrAnAlgebra) : ι 𝓝ᶠ(
-/
lemma ι_normalOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
lemma ι_normalOrderF_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
(h : a ∈ TwoSidedIdeal.span 𝓕.fieldOpIdealSet) : ι 𝓝ᶠ(a) = 0 := by
rw [TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure] at h
let p {k : Set 𝓕.CrAnAlgebra} (a : CrAnAlgebra 𝓕) (h : a ∈ AddSubgroup.closure k) := ι 𝓝ᶠ(a) = 0
@ -210,16 +211,16 @@ lemma ι_normalOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
· intro x hx
simp [p]
lemma ι_normalOrder_eq_of_equiv (a b : 𝓕.CrAnAlgebra) (h : a ≈ b) :
lemma ι_normalOrderF_eq_of_equiv (a b : 𝓕.CrAnAlgebra) (h : a ≈ b) :
ι 𝓝ᶠ(a) = ι 𝓝ᶠ(b) := by
rw [equiv_iff_sub_mem_ideal] at h
rw [LinearMap.sub_mem_ker_iff.mp]
simp only [LinearMap.mem_ker, ← map_sub]
exact ι_normalOrder_zero_of_mem_ideal (a - b) h
exact ι_normalOrderF_zero_of_mem_ideal (a - b) h
/-- Normal ordering on `FieldOpAlgebra`. -/
noncomputable def normalOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where
toFun := Quotient.lift (ι.toLinearMap ∘ₗ CrAnAlgebra.normalOrder) ι_normalOrder_eq_of_equiv
toFun := Quotient.lift (ι.toLinearMap ∘ₗ normalOrderF) ι_normalOrderF_eq_of_equiv
map_add' x y := by
obtain ⟨x, rfl⟩ := ι_surjective x
obtain ⟨y, rfl⟩ := ι_surjective y
@ -231,5 +232,331 @@ noncomputable def normalOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra
rw [← map_smul, ι_apply, ι_apply]
simp
@[inherit_doc normalOrder]
scoped[FieldSpecification.FieldOpAlgebra] notation "𝓝(" a ")" => normalOrder a
/-!
## Properties of normal ordering.
-/
lemma normalOrder_eq_ι_normalOrderF (a : 𝓕.CrAnAlgebra) :
𝓝(ι a) = ι 𝓝ᶠ(a) := rfl
lemma normalOrder_ofCrAnFieldOpList (φs : List 𝓕.CrAnStates) :
𝓝(ofCrAnFieldOpList φs) = normalOrderSign φs • ofCrAnFieldOpList (normalOrderList φs) := by
rw [ofCrAnFieldOpList, normalOrder_eq_ι_normalOrderF, normalOrderF_ofCrAnList]
rfl
lemma ofCrAnFieldOpList_eq_normalOrder (φs : List 𝓕.CrAnStates) :
ofCrAnFieldOpList (normalOrderList φs) = normalOrderSign φs • 𝓝(ofCrAnFieldOpList φs) := by
rw [normalOrder_ofCrAnFieldOpList, smul_smul, normalOrderSign, Wick.koszulSign_mul_self,
one_smul]
/-!
## mul anpart and crpart
-/
lemma normalOrder_mul_anPart (φ : 𝓕.States) (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) :
𝓝(crPart φ * a) = crPart φ * 𝓝(a) := by
obtain ⟨a, rfl⟩ := ι_surjective a
rw [crPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul]
rfl
/-!
### Normal order and super commutes
-/
@[simp]
lemma normalOrder_superCommute_eq_zero (a b : 𝓕.FieldOpAlgebra) :
𝓝([a, b]ₛ) = 0 := by
obtain ⟨a, rfl⟩ := ι_surjective a
obtain ⟨b, rfl⟩ := ι_surjective b
rw [superCommute_eq_ι_superCommuteF, normalOrder_eq_ι_normalOrderF]
simp
@[simp]
lemma normalOrder_superCommute_left_eq_zero (a b c: 𝓕.FieldOpAlgebra) :
𝓝([a, b]ₛ * c) = 0 := by
obtain ⟨a, rfl⟩ := ι_surjective a
obtain ⟨b, rfl⟩ := ι_surjective b
obtain ⟨c, rfl⟩ := ι_surjective c
rw [superCommute_eq_ι_superCommuteF, ← map_mul, normalOrder_eq_ι_normalOrderF]
simp
@[simp]
lemma normalOrder_superCommute_right_eq_zero (a b c: 𝓕.FieldOpAlgebra) :
𝓝(c * [a, b]ₛ) = 0 := by
obtain ⟨a, rfl⟩ := ι_surjective a
obtain ⟨b, rfl⟩ := ι_surjective b
obtain ⟨c, rfl⟩ := ι_surjective c
rw [superCommute_eq_ι_superCommuteF, ← map_mul, normalOrder_eq_ι_normalOrderF]
simp
@[simp]
lemma normalOrder_superCommute_mid_eq_zero (a b c d : 𝓕.FieldOpAlgebra) :
𝓝(a * [c, d]ₛ * b) = 0 := by
obtain ⟨a, rfl⟩ := ι_surjective a
obtain ⟨b, rfl⟩ := ι_surjective b
obtain ⟨c, rfl⟩ := ι_surjective c
obtain ⟨d, rfl⟩ := ι_surjective d
rw [superCommute_eq_ι_superCommuteF, ← map_mul, ← map_mul, normalOrder_eq_ι_normalOrderF]
simp
/-!
### Swapping terms in a normal order.
-/
lemma normalOrder_ofFieldOp_ofFieldOp_swap (φ φ' : 𝓕.States) :
𝓝(ofFieldOp φ * ofFieldOp φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝(ofFieldOp φ' * ofFieldOp φ) := by
rw [ofFieldOp_mul_ofFieldOp_eq_superCommute]
simp
lemma normalOrder_ofCrAnFieldOp_ofCrAnFieldOpList (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) : 𝓝(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) :
𝓝(ofCrAnFieldOp φ * ofFieldOpList φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓝(ofFieldOpList φ' * ofCrAnFieldOp φ) := by
rw [← ofCrAnFieldOpList_singleton, ofCrAnFieldOpList_mul_ofFieldOpList_eq_superCommute]
simp
lemma normalOrder_anPart_ofFieldOpList_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
𝓝(anPart φ * ofFieldOpList φ') = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓝(ofFieldOpList φ' * anPart φ) := by
match φ with
| .inAsymp φ =>
simp
| .position φ =>
simp only [anPart_position, instCommGroup.eq_1]
rw [normalOrder_ofCrAnFieldOp_ofFieldOpList_swap]
rfl
| .outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1]
rw [normalOrder_ofCrAnFieldOp_ofFieldOpList_swap]
rfl
lemma normalOrder_ofFieldOpList_anPart_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
𝓝(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) :
𝓝(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') =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • 𝓝(ofFieldOpList φs' * anPart φ) +
[anPart φ, 𝓝(ofFieldOpList φs')]ₛ := by
rw [anPart, ofFieldOpList, normalOrder_eq_ι_normalOrderF, ← map_mul]
rw [anPartF_mul_normalOrderF_ofStateList_eq_superCommuteF]
simp only [instCommGroup.eq_1, map_add, map_smul]
rfl
/-!
## Super commutators with a normal ordered term as sums
-/
lemma ofCrAnFieldOp_superCommute_normalOrder_ofCrAnFieldOpList_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) : [ofCrAnFieldOp φ, 𝓝(ofCrAnFieldOpList φs)]ₛ = ∑ n : Fin φs.length,
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) • [ofCrAnFieldOp φ, ofCrAnFieldOp φs[n]]ₛ
* 𝓝(ofCrAnFieldOpList (φs.eraseIdx n)) := by
rw [normalOrder_ofCrAnFieldOpList, map_smul]
rw [superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum, Finset.smul_sum,
sum_normalOrderList_length]
congr
funext n
simp only [instCommGroup.eq_1, List.get_eq_getElem, normalOrderList_get_normalOrderEquiv,
normalOrderList_eraseIdx_normalOrderEquiv, Algebra.smul_mul_assoc, Fin.getElem_fin]
rw [ofCrAnFieldOpList_eq_normalOrder, mul_smul_comm, smul_smul, smul_smul]
by_cases hs : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[n])
· congr
erw [normalOrderSign_eraseIdx, ← hs]
trans (normalOrderSign φs * normalOrderSign φs) *
(𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv n))) *
𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv n))))
* 𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ (φs.take n))
· ring_nf
rw [hs]
rfl
· simp [hs]
· erw [superCommute_diff_statistic hs]
simp
lemma ofCrAnFieldOp_superCommute_normalOrder_ofFieldOpList_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.States) :
[ofCrAnFieldOp φ, 𝓝(ofFieldOpList φs)]ₛ = ∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
[ofCrAnFieldOp φ, ofFieldOp φs[n]]ₛ * 𝓝(ofFieldOpList (φs.eraseIdx n)) := by
conv_lhs =>
rw [ofFieldOpList_eq_sum, map_sum, map_sum]
enter [2, s]
rw [ofCrAnFieldOp_superCommute_normalOrder_ofCrAnFieldOpList_sum, CrAnSection.sum_over_length]
enter [2, n]
rw [CrAnSection.take_statistics_eq_take_state_statistics, smul_mul_assoc]
rw [Finset.sum_comm]
refine Finset.sum_congr rfl (fun n _ => ?_)
simp only [instCommGroup.eq_1, Fin.coe_cast, Fin.getElem_fin,
CrAnSection.sum_eraseIdxEquiv n _ n.prop,
CrAnSection.eraseIdxEquiv_symm_getElem,
CrAnSection.eraseIdxEquiv_symm_eraseIdx, ← Finset.smul_sum, Algebra.smul_mul_assoc]
conv_lhs =>
enter [2, 2, n]
rw [← Finset.mul_sum]
rw [← Finset.sum_mul, ← map_sum, ← map_sum, ← ofFieldOp_eq_sum, ← ofFieldOpList_eq_sum]
/--
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) :
[anPart φ, 𝓝(ofFieldOpList φs)]ₛ = ∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
[anPart φ, ofState φs[n]]ₛ * 𝓝(ofFieldOpList (φs.eraseIdx n)) := by
match φ with
| .inAsymp φ =>
simp
| .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,
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,
Fin.getElem_fin, Algebra.smul_mul_assoc]
rfl
/-!
## Multiplying with normal ordered terms
-/
/--
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) =
𝓝(anPart φ * ofFieldOpList φs) + [anPart φ, 𝓝(ofFieldOpList φs)]ₛ := by
rw [anPart_mul_normalOrder_ofFieldOpList_eq_superCommute]
simp [instCommGroup.eq_1, map_add, map_smul]
rw [normalOrder_anPart_ofFieldOpList_swap]
/--
Within a proto-operator algebra we have that
`φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ(φφ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
-/
lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute (φ : 𝓕.States)
(φs : List 𝓕.States) : 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,
← crPart_mul_normalOrder, ← map_add]
conv_lhs =>
lhs
rw [← add_mul, ← ofFieldOp_eq_crPart_add_anPart]
/-- In the expansion of `ofState φ * normalOrderF (ofStateList φs)` the element
of `𝓞.A` associated with contracting `φ` with the (optional) `n`th element of `φs`. -/
noncomputable def contractStateAtIndex (φ : 𝓕.States) (φs : List 𝓕.States)
(n : Option (Fin φs.length)) : 𝓕.FieldOpAlgebra :=
match n with
| none => 1
| some n => 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) • [anPart φ, ofFieldOp φs[n]]ₛ
/--
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) =
∑ n : Option (Fin φs.length), contractStateAtIndex φ φs n *
𝓝(ofFieldOpList (HepLean.List.optionEraseZ φs φ n)) := by
rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_superCommute]
rw [anPart_superCommute_normalOrder_ofFieldOpList_sum]
simp only [instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc, contractStateAtIndex,
Fintype.sum_option, one_mul]
rfl
/-!
## Cons vs insertIdx for a normal ordered term.
-/
/--
Within a proto-operator algebra, `N(φφ₀φ₁…φₙ) = s • N(φ₀…φₖ₋₁φφₖ…φₙ)`, where
`s` is the exchange sign for `φ` and `φ₀…φₖ₋₁`.
-/
lemma ofFieldOpList_normalOrder_insert (φ : 𝓕.States) (φs : List 𝓕.States)
(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
rw [HepLean.List.insertIdx_eq_take_drop]
simp
rw [hl]
rw [ofFieldOpList_append, ofFieldOpList_append]
rw [ofFieldOpList_mul_ofFieldOpList_eq_superCommute, add_mul]
simp [instCommGroup.eq_1, Nat.succ_eq_add_one, ofList_singleton, Algebra.smul_mul_assoc,
map_add, map_smul, add_zero, smul_smul,
exchangeSign_mul_self_swap, one_smul]
rw [← ofFieldOpList_append, ← ofFieldOpList_append]
simp
/-!
## The normal ordering of a product of two states
-/
@[simp]
lemma normalOrder_crPart_mul_crPart (φ φ' : 𝓕.States) :
𝓝(crPart φ * crPart φ') = crPart φ * crPart φ' := by
rw [crPart, crPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul_crPartF]
@[simp]
lemma normalOrder_anPart_mul_anPart (φ φ' : 𝓕.States) :
𝓝(anPart φ * anPart φ') = anPart φ * anPart φ' := by
rw [anPart, anPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_anPartF_mul_anPartF]
@[simp]
lemma normalOrder_crPart_mul_anPart (φ φ' : 𝓕.States) :
𝓝(crPart φ * anPart φ') = crPart φ * anPart φ' := by
rw [crPart, anPart, ← map_mul, normalOrder_eq_ι_normalOrderF, normalOrderF_crPartF_mul_anPartF]
@[simp]
lemma normalOrder_anPart_mul_crPart (φ φ' : 𝓕.States) :
𝓝(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 φ') =
crPart φ * crPart φ' + 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • (crPart φ' * anPart φ) +
crPart φ * anPart φ' + anPart φ * anPart φ' := by
rw [ofFieldOp, ofFieldOp, ← map_mul, normalOrder_eq_ι_normalOrderF,
normalOrderF_ofState_mul_ofState]
rfl
end FieldOpAlgebra
end FieldSpecification

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

@ -19,15 +19,15 @@ open FieldStatistic
namespace FieldOpAlgebra
variable {𝓕 : FieldSpecification}
lemma ι_superCommute_eq_zero_of_ι_right_zero (a b : 𝓕.CrAnAlgebra) (h : ι b = 0) :
lemma ι_superCommuteF_eq_zero_of_ι_right_zero (a b : 𝓕.CrAnAlgebra) (h : ι b = 0) :
ι [a, b]ₛca = 0 := by
rw [superCommute_expand_bosonicProj_fermionicProj]
rw [superCommuteF_expand_bosonicProj_fermionicProj]
rw [ι_eq_zero_iff_ι_bosonicProj_fermonicProj_zero] at h
simp_all
lemma ι_superCommute_eq_zero_of_ι_left_zero (a b : 𝓕.CrAnAlgebra) (h : ι a = 0) :
lemma ι_superCommuteF_eq_zero_of_ι_left_zero (a b : 𝓕.CrAnAlgebra) (h : ι a = 0) :
ι [a, b]ₛca = 0 := by
rw [superCommute_expand_bosonicProj_fermionicProj]
rw [superCommuteF_expand_bosonicProj_fermionicProj]
rw [ι_eq_zero_iff_ι_bosonicProj_fermonicProj_zero] at h
simp_all
@ -37,23 +37,23 @@ lemma ι_superCommute_eq_zero_of_ι_left_zero (a b : 𝓕.CrAnAlgebra) (h : ι a
-/
lemma ι_superCommute_right_zero_of_mem_ideal (a b : 𝓕.CrAnAlgebra)
lemma ι_superCommuteF_right_zero_of_mem_ideal (a b : 𝓕.CrAnAlgebra)
(h : b ∈ TwoSidedIdeal.span 𝓕.fieldOpIdealSet) : ι [a, b]ₛca = 0 := by
apply ι_superCommute_eq_zero_of_ι_right_zero
apply ι_superCommuteF_eq_zero_of_ι_right_zero
exact (ι_eq_zero_iff_mem_ideal b).mpr h
lemma ι_superCommute_eq_of_equiv_right (a b1 b2 : 𝓕.CrAnAlgebra) (h : b1 ≈ b2) :
lemma ι_superCommuteF_eq_of_equiv_right (a b1 b2 : 𝓕.CrAnAlgebra) (h : b1 ≈ b2) :
ι [a, b1]ₛca = ι [a, b2]ₛca := by
rw [equiv_iff_sub_mem_ideal] at h
rw [LinearMap.sub_mem_ker_iff.mp]
simp only [LinearMap.mem_ker, ← map_sub]
exact ι_superCommute_right_zero_of_mem_ideal a (b1 - b2) h
exact ι_superCommuteF_right_zero_of_mem_ideal a (b1 - b2) h
/-- The super commutor on the `FieldOpAlgebra` defined as a linear map `[a,_]ₛ`. -/
noncomputable def superCommuteRight (a : 𝓕.CrAnAlgebra) :
FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where
toFun := Quotient.lift (ι.toLinearMap ∘ₗ CrAnAlgebra.superCommute a)
(ι_superCommute_eq_of_equiv_right a)
toFun := Quotient.lift (ι.toLinearMap ∘ₗ superCommuteF a)
(ι_superCommuteF_eq_of_equiv_right a)
map_add' x y := by
obtain ⟨x, hx⟩ := ι_surjective x
obtain ⟨y, hy⟩ := ι_surjective y
@ -80,10 +80,10 @@ lemma superCommuteRight_eq_of_equiv (a1 a2 : 𝓕.CrAnAlgebra) (h : a1 ≈ a2) :
obtain ⟨b, rfl⟩ := ι_surjective b
have ha1b1 : (superCommuteRight (a1 - a2)) (ι b) = 0 := by
rw [superCommuteRight_apply_ι]
apply ι_superCommute_eq_zero_of_ι_left_zero
apply ι_superCommuteF_eq_zero_of_ι_left_zero
exact (ι_eq_zero_iff_mem_ideal (a1 - a2)).mpr h
simp_all only [superCommuteRight_apply_ι, map_sub, LinearMap.sub_apply]
trans ι ((superCommute a2) b) + 0
trans ι ((superCommuteF a2) b) + 0
rw [← ha1b1]
simp only [add_sub_cancel]
simp
@ -111,8 +111,407 @@ noncomputable def superCommute : FieldOpAlgebra 𝓕 →ₗ[ℂ]
rw [superCommuteRight_apply_quot, superCommuteRight_apply_quot]
simp
lemma ι_superCommute (a b : 𝓕.CrAnAlgebra) : ι [a, b]ₛca = superCommute (ι a) (ι b) := by
@[inherit_doc superCommute]
scoped[FieldSpecification.FieldOpAlgebra] notation "[" a "," b "]ₛ" => superCommute a b
lemma superCommute_eq_ι_superCommuteF (a b : 𝓕.CrAnAlgebra) :
[ι a, ι b]ₛ = ι [a, b]ₛca := rfl
/-!
## Properties of `superCommute`.
-/
/-!
## Properties from the definition of FieldOpAlgebra
-/
lemma superCommute_create_create {φ φ' : 𝓕.CrAnStates}
(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}
(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 : (𝓕 |>ₛ φ) ≠ 𝓕 |>ₛ φ') :
[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)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : [ofCrAnFieldOp φ, ofFieldOp ψ]ₛ = 0 := by
rw [ofFieldOp_eq_sum, map_sum]
rw [Finset.sum_eq_zero]
intro x hx
apply superCommute_diff_statistic
simpa [crAnStatistics] using h
lemma superCommute_anPart_ofState_diff_grade_zero (φ ψ : 𝓕.States)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) : [anPart φ, ofFieldOp ψ]ₛ = 0 := by
match φ with
| States.inAsymp _ =>
simp
| States.position φ =>
simp only [anPartF_position]
apply superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero _ _ _
simpa [crAnStatistics] using h
| States.outAsymp _ =>
simp only [anPartF_posAsymp]
apply superCommute_ofCrAnFieldOp_ofFieldOp_diff_stat_zero _ _
simpa [crAnStatistics] using h
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center (φ φ' : 𝓕.CrAnStates) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
rw [ofCrAnFieldOp, ofCrAnFieldOp, superCommute_eq_ι_superCommuteF]
exact ι_superCommuteF_ofCrAnState_ofCrAnState_mem_center φ φ'
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_commute (φ φ' : 𝓕.CrAnStates)
(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) :
[ofCrAnFieldOp φ, ofFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
rw [ofFieldOp_eq_sum]
simp only [map_sum]
refine Subalgebra.sum_mem (Subalgebra.center ℂ 𝓕.FieldOpAlgebra) ?_
intro x hx
exact superCommute_ofCrAnFieldOp_ofCrAnFieldOp_mem_center φ ⟨φ', x⟩
lemma superCommute_ofCrAnFieldOp_ofFieldOp_commute (φ : 𝓕.CrAnStates) (φ' : 𝓕.States)
(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) :
[anPart φ, ofFieldOp φ']ₛ ∈ Subalgebra.center ℂ (FieldOpAlgebra 𝓕) := by
match φ with
| States.inAsymp _ =>
simp only [anPart_negAsymp, map_zero, LinearMap.zero_apply]
exact Subalgebra.zero_mem (Subalgebra.center ℂ _)
| States.position φ =>
exact superCommute_ofCrAnFieldOp_ofFieldOp_mem_center _ _
| States.outAsymp _ =>
exact superCommute_ofCrAnFieldOp_ofFieldOp_mem_center _ _
/-!
### `superCommute` on different constructors.
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
ofCrAnFieldOpList (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnFieldOpList (φs' ++ φs) := by
rw [ofCrAnFieldOpList_eq_ι_ofCrAnList, ofCrAnFieldOpList_eq_ι_ofCrAnList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnList_ofCrAnList]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp (φ φ' : 𝓕.CrAnStates) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ = ofCrAnFieldOp φ * ofCrAnFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofCrAnFieldOp φ' * ofCrAnFieldOp φ := by
rw [ofCrAnFieldOp, ofCrAnFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnState_ofCrAnState]
rfl
lemma superCommute_ofCrAnFieldOpList_ofFieldOpList (φcas : List 𝓕.CrAnStates)
(φs : List 𝓕.States) :
[ofCrAnFieldOpList φcas, ofFieldOpList φs]ₛ = ofCrAnFieldOpList φcas * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φcas, 𝓕 |>ₛ φs) • ofFieldOpList φs * ofCrAnFieldOpList φcas := by
rw [ofCrAnFieldOpList, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofCrAnList_ofStatesList]
rfl
lemma superCommute_ofFieldOpList_ofFieldOpList (φs φs' : List 𝓕.States) :
[ofFieldOpList φs, ofFieldOpList φs']ₛ = ofFieldOpList φs * ofFieldOpList φs' -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofStateList_ofStatesList]
rfl
lemma superCommute_ofFieldOp_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
[ofFieldOp φ, ofFieldOpList φs]ₛ = ofFieldOp φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * ofFieldOp φ := by
rw [ofFieldOp, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofState_ofStatesList]
rfl
lemma superCommute_ofFieldOpList_ofFieldOp (φs : List 𝓕.States) (φ : 𝓕.States) :
[ofFieldOpList φs, ofFieldOp φ]ₛ = ofFieldOpList φs * ofFieldOp φ -
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φ) • ofFieldOp φ * ofFieldOpList φs := by
rw [ofFieldOpList, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_ofStateList_ofState]
rfl
lemma superCommute_anPart_crPart (φ φ' : 𝓕.States) :
[anPart φ, crPart φ']ₛ = anPart φ * crPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ := by
rw [anPart, crPart]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_crPartF]
rfl
lemma superCommute_crPart_anPart (φ φ' : 𝓕.States) :
[crPart φ, anPart φ']ₛ = crPart φ * anPart φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * crPart φ := by
rw [anPart, crPart]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_anPartF]
rfl
@[simp]
lemma superCommute_crPart_crPart (φ φ' : 𝓕.States) : [crPart φ, crPart φ']ₛ = 0 := by
match φ, φ' with
| States.outAsymp φ, _ =>
simp
| _, States.outAsymp φ =>
simp
| States.position φ, States.position φ' =>
simp only [crPart_position]
apply superCommute_create_create
· rfl
· rfl
| States.position φ, States.inAsymp φ' =>
simp only [crPart_position, crPart_negAsymp]
apply superCommute_create_create
· rfl
· rfl
| States.inAsymp φ, States.inAsymp φ' =>
simp only [crPart_negAsymp]
apply superCommute_create_create
· rfl
· rfl
| States.inAsymp φ, States.position φ' =>
simp only [crPart_negAsymp, crPart_position]
apply superCommute_create_create
· rfl
· rfl
@[simp]
lemma superCommute_anPart_anPart (φ φ' : 𝓕.States) : [anPart φ, anPart φ']ₛ = 0 := by
match φ, φ' with
| States.inAsymp φ, _ =>
simp
| _, States.inAsymp φ =>
simp
| States.position φ, States.position φ' =>
simp only [anPart_position]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.position φ, States.outAsymp φ' =>
simp only [anPart_position, anPart_posAsymp]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.outAsymp φ, States.outAsymp φ' =>
simp only [anPart_posAsymp]
apply superCommute_annihilate_annihilate
· rfl
· rfl
| States.outAsymp φ, States.position φ' =>
simp only [anPart_posAsymp, anPart_position]
apply superCommute_annihilate_annihilate
· rfl
· rfl
lemma superCommute_crPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
[crPart φ, ofFieldOpList φs]ₛ = crPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * crPart φ := by
rw [crPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofStateList]
rfl
lemma superCommute_anPart_ofFieldOpList (φ : 𝓕.States) (φs : List 𝓕.States) :
[anPart φ, ofFieldOpList φs]ₛ = anPart φ * ofFieldOpList φs -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • ofFieldOpList φs * anPart φ := by
rw [anPart, ofFieldOpList]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_ofStateList]
rfl
lemma superCommute_crPart_ofFieldOp (φ φ' : 𝓕.States) :
[crPart φ, ofFieldOp φ']ₛ = crPart φ * ofFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOp φ' * crPart φ := by
rw [crPart, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_crPartF_ofState]
rfl
lemma superCommute_anPart_ofFieldOp (φ φ' : 𝓕.States) :
[anPart φ, ofFieldOp φ']ₛ = anPart φ * ofFieldOp φ' -
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • ofFieldOp φ' * anPart φ := by
rw [anPart, ofFieldOp]
rw [superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_ofState]
rfl
/-!
## Mul equal superCommute
Lemmas which rewrite a multiplication of two elements of the algebra as their commuted
multiplication with a sign plus the super commutor.
-/
lemma ofCrAnFieldOpList_mul_ofCrAnFieldOpList_eq_superCommute (φs φs' : List 𝓕.CrAnStates) :
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' =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ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) :
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) :
ofFieldOp φ * ofFieldOpList φs' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofFieldOp φ
+ [ofFieldOp φ, ofFieldOpList φs']ₛ := by
rw [superCommute_ofFieldOp_ofFieldOpList]
simp
lemma ofFieldOp_mul_ofFieldOp_eq_superCommute (φ φ' : 𝓕.States) :
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) :
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' =
𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofFieldOpList φs' * ofCrAnFieldOpList φs
+ [ofCrAnFieldOpList φs, ofFieldOpList φs']ₛ := by
rw [superCommute_ofCrAnFieldOpList_ofFieldOpList]
simp
lemma crPart_mul_anPart_eq_superCommute (φ φ' : 𝓕.States) :
crPart φ * anPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * crPart φ
+ [crPart φ, anPart φ']ₛ := by
rw [superCommute_crPart_anPart]
simp
lemma anPart_mul_crPart_eq_superCommute (φ φ' : 𝓕.States) :
anPart φ * crPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • crPart φ' * anPart φ
+ [anPart φ, crPart φ']ₛ := by
rw [superCommute_anPart_crPart]
simp
lemma crPart_mul_crPart_swap (φ φ' : 𝓕.States) :
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) :
anPart φ * anPart φ' = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * anPart φ := by
trans 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • anPart φ' * anPart φ + [anPart φ, anPart φ']ₛ
· rw [anPart, anPart, superCommute_eq_ι_superCommuteF, superCommuteF_anPartF_anPartF]
simp
· simp
/-!
## Symmetry of the super commutor.
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_symm (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
(- 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs')) • [ofCrAnFieldOpList φs', ofCrAnFieldOpList φs]ₛ := by
rw [ofCrAnFieldOpList, ofCrAnFieldOpList, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnList_ofCrAnList_symm]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOp_symm (φ φ' : 𝓕.CrAnStates) :
[ofCrAnFieldOp φ, ofCrAnFieldOp φ']ₛ =
(- 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ')) • [ofCrAnFieldOp φ', ofCrAnFieldOp φ]ₛ := by
rw [ofCrAnFieldOp, ofCrAnFieldOp, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnState_ofCrAnState_symm]
rfl
/-!
## splitting the super commute into sums
-/
lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum (φs φs' : List 𝓕.CrAnStates) :
[ofCrAnFieldOpList φs, ofCrAnFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofCrAnFieldOpList (φs'.take n) * [ofCrAnFieldOpList φs, ofCrAnFieldOp (φs'.get n)]ₛ *
ofCrAnFieldOpList (φs'.drop (n + 1)) := by
conv_lhs =>
rw [ofCrAnFieldOpList, ofCrAnFieldOpList, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnList_ofCrAnList_eq_sum]
rw [map_sum]
rfl
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum (φ : 𝓕.CrAnStates)
(φs' : List 𝓕.CrAnStates) : [ofCrAnFieldOp φ, ofCrAnFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs'.take n) •
[ofCrAnFieldOp φ, ofCrAnFieldOp (φs'.get n)]ₛ * ofCrAnFieldOpList (φs'.eraseIdx n) := by
conv_lhs =>
rw [← ofCrAnFieldOpList_singleton, superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum]
congr
funext n
simp only [instCommGroup.eq_1, ofList_singleton, List.get_eq_getElem, Algebra.smul_mul_assoc]
congr 1
rw [ofCrAnFieldOpList_singleton, superCommute_ofCrAnFieldOp_ofCrAnFieldOp_commute]
rw [mul_assoc, ← ofCrAnFieldOpList_append]
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']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) •
ofFieldOpList (φs'.take n) * [ofCrAnFieldOpList φs, ofFieldOp (φs'.get n)]ₛ *
ofFieldOpList (φs'.drop (n + 1)) := by
conv_lhs =>
rw [ofCrAnFieldOpList, ofFieldOpList, superCommute_eq_ι_superCommuteF,
superCommuteF_ofCrAnList_ofStateList_eq_sum]
rw [map_sum]
rfl
lemma superCommute_ofCrAnFieldOp_ofFieldOpList_eq_sum (φ : 𝓕.CrAnStates) (φs' : List 𝓕.States) :
[ofCrAnFieldOp φ, ofFieldOpList φs']ₛ =
∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs'.take n) •
[ofCrAnFieldOp φ, ofFieldOp (φs'.get n)]ₛ * ofFieldOpList (φs'.eraseIdx n) := by
conv_lhs =>
rw [← ofCrAnFieldOpList_singleton, superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum]
congr
funext n
simp only [instCommGroup.eq_1, ofList_singleton, List.get_eq_getElem, Algebra.smul_mul_assoc]
congr 1
rw [ofCrAnFieldOpList_singleton, superCommute_ofCrAnFieldOp_ofFieldOp_commute]
rw [mul_assoc, ← ofFieldOpList_append]
congr
exact Eq.symm (List.eraseIdx_eq_take_drop_succ φs' ↑n)
end FieldOpAlgebra
end FieldSpecification

87
HepLean/PerturbationTheory/Algebras/FieldOpAlgebra/TimeContraction.lean Normal file
View file

@ -0,0 +1,87 @@
/-
Copyright (c) 2025 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.TimeOrder
/-!
# Time contractions
We define the state algebra of a field structure to be the free algebra
generated by the states.
-/
namespace FieldSpecification
variable {𝓕 : FieldSpecification}
open CrAnAlgebra
noncomputable section
namespace FieldOpAlgebra
open FieldStatistic
/-- The time contraction of two States 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 :=
𝓣(ofFieldOp φ * ofFieldOp ψ) - 𝓝(ofFieldOp φ * ofFieldOp ψ)
lemma timeContract_eq_smul (φ ψ : 𝓕.States) : timeContract φ ψ =
𝓣(ofFieldOp φ * ofFieldOp ψ) + (-1 : ℂ) • 𝓝(ofFieldOp φ * ofFieldOp ψ) := by rfl
lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.States) (h : timeOrderRel φ ψ) :
timeContract φ ψ = [anPart φ, ofFieldOp ψ]ₛ := by
conv_rhs =>
rw [ofFieldOp_eq_crPart_add_anPart]
rw [map_add, superCommute_anPart_anPart, superCommute_anPart_crPart]
simp only [timeContract, instCommGroup.eq_1, Algebra.smul_mul_assoc, add_zero]
rw [timeOrder_ofFieldOp_ofFieldOp_ordered h]
rw [normalOrder_ofFieldOp_mul_ofFieldOp]
simp only [instCommGroup.eq_1]
rw [ofFieldOp_eq_crPart_add_anPart, ofFieldOp_eq_crPart_add_anPart]
simp only [mul_add, add_mul]
abel_nf
lemma timeContract_of_not_timeOrderRel (φ ψ : 𝓕.States) (h : ¬ timeOrderRel φ ψ) :
timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • timeContract ψ φ := by
rw [timeContract_eq_smul]
simp only [Int.reduceNeg, one_smul, map_add]
rw [normalOrder_ofFieldOp_ofFieldOp_swap]
rw [timeOrder_ofFieldOp_ofFieldOp_not_ordered_eq_timeOrder h]
rw [timeContract_eq_smul]
simp only [instCommGroup.eq_1, map_smul, map_add, smul_add]
rw [smul_smul, smul_smul, mul_comm]
lemma timeContract_mem_center (φ ψ : 𝓕.States) :
timeContract φ ψ ∈ Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
by_cases h : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ h]
exact superCommute_anPart_ofFieldOp_mem_center φ ψ
· rw [timeContract_of_not_timeOrderRel _ _ h]
refine Subalgebra.smul_mem (Subalgebra.center ℂ _) ?_ 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ)
rw [timeContract_of_timeOrderRel]
exact superCommute_anPart_ofFieldOp_mem_center _ _
have h1 := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
lemma timeContract_zero_of_diff_grade (φ ψ : 𝓕.States) (h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
timeContract φ ψ = 0 := by
by_cases h1 : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ h1]
rw [superCommute_anPart_ofState_diff_grade_zero]
exact h
· rw [timeContract_of_not_timeOrderRel _ _ h1]
rw [timeContract_of_timeOrderRel _ _ _]
rw [superCommute_anPart_ofState_diff_grade_zero]
simp only [instCommGroup.eq_1, smul_zero]
exact h.symm
have ht := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
end FieldOpAlgebra
end
end FieldSpecification

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

@ -19,7 +19,7 @@ open FieldStatistic
namespace FieldOpAlgebra
variable {𝓕 : FieldSpecification}
lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_superCommuteF_eq_time_ofCrAnList {φ1 φ2 φ3 : 𝓕.CrAnStates}
(φs1 φs2 : List 𝓕.CrAnStates) (h :
crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
@ -38,7 +38,7 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
• (ι (ofCrAnList l1) * ι (ofCrAnList [φ1, φ2, φ3]) * ι (ofCrAnList l2)) := by
have h1 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ1 φs1 [φ1, φ2, φ3] φs2
(by simp_all)
rw [timeOrder_ofCrAnList, show φs1 ++ φ1 :: φ2 :: φ3 :: φs2 = φs1 ++ [φ1, φ2, φ3] ++ φs2
rw [timeOrderF_ofCrAnList, show φs1 ++ φ1 :: φ2 :: φ3 :: φs2 = φs1 ++ [φ1, φ2, φ3] ++ φs2
by simp, crAnTimeOrderList, h1]
simp only [List.append_assoc, List.singleton_append, decide_not,
Bool.decide_and, ofCrAnList_append, map_smul, map_mul, l1, l2, mul_assoc]
@ -47,7 +47,7 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
• (ι (ofCrAnList l1) * ι (ofCrAnList [φ1, φ3, φ2]) * ι (ofCrAnList l2)) := by
have h1 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ1 φs1 [φ1, φ3, φ2] φs2
(by simp_all)
rw [timeOrder_ofCrAnList, show φs1 ++ φ1 :: φ3 :: φ2 :: φs2 = φs1 ++ [φ1, φ3, φ2] ++ φs2
rw [timeOrderF_ofCrAnList, show φs1 ++ φ1 :: φ3 :: φ2 :: φs2 = φs1 ++ [φ1, φ3, φ2] ++ φs2
by simp, crAnTimeOrderList, h1]
simp only [List.singleton_append, decide_not,
Bool.decide_and, ofCrAnList_append, map_smul, map_mul, l1, l2, mul_assoc]
@ -72,7 +72,7 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
• (ι (ofCrAnList l1) * ι (ofCrAnList [φ2, φ3, φ1]) * ι (ofCrAnList l2)) := by
have h1 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ1 φs1 [φ2, φ3, φ1] φs2
(by simp_all)
rw [timeOrder_ofCrAnList, show φs1 ++ φ2 :: φ3 :: φ1 :: φs2 = φs1 ++ [φ2, φ3, φ1] ++ φs2
rw [timeOrderF_ofCrAnList, show φs1 ++ φ2 :: φ3 :: φ1 :: φs2 = φs1 ++ [φ2, φ3, φ1] ++ φs2
by simp, crAnTimeOrderList, h1]
simp only [List.singleton_append, decide_not,
Bool.decide_and, ofCrAnList_append, map_smul, map_mul, l1, l2, mul_assoc]
@ -90,7 +90,7 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
• (ι (ofCrAnList l1) * ι (ofCrAnList [φ3, φ2, φ1]) * ι (ofCrAnList l2)) := by
have h1 := insertionSort_of_eq_list 𝓕.crAnTimeOrderRel φ1 φs1 [φ3, φ2, φ1] φs2
(by simp_all)
rw [timeOrder_ofCrAnList, show φs1 ++ φ3 :: φ2 :: φ1 :: φs2 = φs1 ++ [φ3, φ2, φ1] ++ φs2
rw [timeOrderF_ofCrAnList, show φs1 ++ φ3 :: φ2 :: φ1 :: φs2 = φs1 ++ [φ3, φ2, φ1] ++ φs2
by simp, crAnTimeOrderList, h1]
simp only [List.singleton_append, decide_not,
Bool.decide_and, ofCrAnList_append, map_smul, map_mul, l1, l2, mul_assoc]
@ -107,9 +107,9 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
subst hφ4
simp_all
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_singleton]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp only [List.singleton_append, instCommGroup.eq_1, ofList_singleton, map_sub, map_smul]
rw [superCommute_ofCrAnList_ofCrAnList, superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList, superCommuteF_ofCrAnList_ofCrAnList]
simp only [List.cons_append, List.nil_append, instCommGroup.eq_1, ofList_singleton, mul_sub, ←
ofCrAnList_append, Algebra.mul_smul_comm, sub_mul, List.append_assoc, Algebra.smul_mul_assoc,
map_sub, map_smul]
@ -132,14 +132,14 @@ lemma ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList {φ1 φ2 φ3 :
rw [mul_assoc]
congr
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_singleton]
rw [superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList]
simp only [List.singleton_append, instCommGroup.eq_1, ofList_singleton, map_sub, map_smul]
rw [superCommute_ofCrAnList_ofCrAnList, superCommute_ofCrAnList_ofCrAnList]
rw [superCommuteF_ofCrAnList_ofCrAnList, superCommuteF_ofCrAnList_ofCrAnList]
simp only [List.cons_append, List.nil_append, instCommGroup.eq_1, ofList_singleton, map_sub,
map_smul, smul_sub]
simp_all
lemma ι_timeOrder_superCommute_superCommute_ofCrAnList {φ1 φ2 φ3 : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_superCommuteF_ofCrAnList {φ1 φ2 φ3 : 𝓕.CrAnStates}
(φs1 φs2 : List 𝓕.CrAnStates) :
ι 𝓣ᶠ(ofCrAnList φs1 * [ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca * ofCrAnList φs2)
= 0 := by
@ -147,13 +147,13 @@ lemma ι_timeOrder_superCommute_superCommute_ofCrAnList {φ1 φ2 φ3 : 𝓕.CrAn
crAnTimeOrderRel φ1 φ2 ∧ crAnTimeOrderRel φ1 φ3 ∧
crAnTimeOrderRel φ2 φ1 ∧ crAnTimeOrderRel φ2 φ3 ∧
crAnTimeOrderRel φ3 φ1 ∧ crAnTimeOrderRel φ3 φ2
· exact ι_timeOrder_superCommute_superCommute_eq_time_ofCrAnList φs1 φs2 h
· rw [timeOrder_timeOrder_mid]
rw [timeOrder_superCommute_ofCrAnState_superCommute_all_not_crAnTimeOrderRel _ _ _ h]
· exact ι_timeOrderF_superCommuteF_superCommuteF_eq_time_ofCrAnList φs1 φs2 h
· rw [timeOrderF_timeOrderF_mid]
rw [timeOrderF_superCommuteF_ofCrAnState_superCommuteF_all_not_crAnTimeOrderRel _ _ _ h]
simp
@[simp]
lemma ι_timeOrder_superCommute_superCommute {φ1 φ2 φ3 : 𝓕.CrAnStates} (a b : 𝓕.CrAnAlgebra) :
lemma ι_timeOrderF_superCommuteF_superCommuteF {φ1 φ2 φ3 : 𝓕.CrAnStates} (a b : 𝓕.CrAnAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca * b) = 0 := by
let pb (b : 𝓕.CrAnAlgebra) (hc : b ∈ Submodule.span ℂ (Set.range ofCrAnListBasis)) :
Prop := ι 𝓣ᶠ(a * [ofCrAnState φ1, [ofCrAnState φ2, ofCrAnState φ3]ₛca]ₛca * b) = 0
@ -169,7 +169,7 @@ lemma ι_timeOrder_superCommute_superCommute {φ1 φ2 φ3 : 𝓕.CrAnStates} (a
· intro x hx
obtain ⟨φs', rfl⟩ := hx
simp only [ofListBasis_eq_ofList, pa]
exact ι_timeOrder_superCommute_superCommute_ofCrAnList φs' φs
exact ι_timeOrderF_superCommuteF_superCommuteF_ofCrAnList φs' φs
· simp [pa]
· intro x y hx hy hpx hpy
simp_all [pa,mul_add, add_mul]
@ -181,7 +181,7 @@ lemma ι_timeOrder_superCommute_superCommute {φ1 φ2 φ3 : 𝓕.CrAnStates} (a
· intro x hx hpx
simp_all [pb, hpx]
lemma ι_timeOrder_superCommute_eq_time {φ ψ : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_eq_time {φ ψ : 𝓕.CrAnStates}
(hφψ : crAnTimeOrderRel φ ψ) (hψφ : crAnTimeOrderRel ψ φ) (a b : 𝓕.CrAnAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) =
ι ([ofCrAnState φ, ofCrAnState ψ]ₛca * 𝓣ᶠ(a * b)) := by
@ -202,9 +202,9 @@ lemma ι_timeOrder_superCommute_eq_time {φ ψ : 𝓕.CrAnStates}
obtain ⟨φs', rfl⟩ := hx
simp only [ofListBasis_eq_ofList, map_mul, pa]
conv_lhs =>
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, superCommuteF_ofCrAnList_ofCrAnList]
simp [mul_sub, sub_mul, ← ofCrAnList_append]
rw [timeOrder_ofCrAnList, timeOrder_ofCrAnList]
rw [timeOrderF_ofCrAnList, timeOrderF_ofCrAnList]
have h1 : crAnTimeOrderSign (φs' ++ φ :: ψ :: φs) =
crAnTimeOrderSign (φs' ++ ψ :: φ :: φs) := by
trans crAnTimeOrderSign (φs' ++ [φ, ψ] ++ φs)
@ -234,16 +234,16 @@ lemma ι_timeOrder_superCommute_eq_time {φ ψ : 𝓕.CrAnStates}
have h1 : (ι (ofCrAnList [φ, ψ]) -
(exchangeSign (𝓕.crAnStatistics φ)) (𝓕.crAnStatistics ψ) • ι (ofCrAnList [ψ, φ])) =
ι [ofCrAnState φ, ofCrAnState ψ]ₛca := by
rw [superCommute_ofCrAnState_ofCrAnState]
rw [superCommuteF_ofCrAnState_ofCrAnState]
rw [← ofCrAnList_singleton, ← ofCrAnList_singleton, ← ofCrAnList_append]
simp only [instCommGroup.eq_1, List.singleton_append, Algebra.smul_mul_assoc, map_sub,
map_smul]
rw [← ofCrAnList_append]
simp
rw [h1]
have hc : ι ((superCommute (ofCrAnState φ)) (ofCrAnState ψ)) ∈
have hc : ι ((superCommuteF (ofCrAnState φ)) (ofCrAnState ψ)) ∈
Subalgebra.center ℂ 𝓕.FieldOpAlgebra := by
apply ι_superCommute_ofCrAnState_ofCrAnState_mem_center
apply ι_superCommuteF_ofCrAnState_ofCrAnState_mem_center
rw [Subalgebra.mem_center_iff] at hc
repeat rw [← mul_assoc]
rw [hc]
@ -257,10 +257,10 @@ lemma ι_timeOrder_superCommute_eq_time {φ ψ : 𝓕.CrAnStates}
rw [← h1]
rw [← crAnTimeOrderList]
by_cases hq : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)
· rw [ι_superCommute_of_diff_statistic hq]
· rw [ι_superCommuteF_of_diff_statistic hq]
simp
· rw [crAnTimeOrderSign, Wick.koszulSign_eq_rel_eq_stat _ _, ← crAnTimeOrderSign]
rw [timeOrder_ofCrAnList]
rw [timeOrderF_ofCrAnList]
simp only [map_smul, Algebra.mul_smul_comm]
simp only [List.nil_append]
exact hψφ
@ -277,30 +277,30 @@ lemma ι_timeOrder_superCommute_eq_time {φ ψ : 𝓕.CrAnStates}
· intro x hx hpx
simp_all [pb, hpx]
lemma ι_timeOrder_superCommute_neq_time {φ ψ : 𝓕.CrAnStates}
lemma ι_timeOrderF_superCommuteF_neq_time {φ ψ : 𝓕.CrAnStates}
(hφψ : ¬ (crAnTimeOrderRel φ ψ ∧ crAnTimeOrderRel ψ φ)) (a b : 𝓕.CrAnAlgebra) :
ι 𝓣ᶠ(a * [ofCrAnState φ, ofCrAnState ψ]ₛca * b) = 0 := by
rw [timeOrder_timeOrder_mid]
rw [timeOrderF_timeOrderF_mid]
have hφψ : ¬ (crAnTimeOrderRel φ ψ) ∨ ¬ (crAnTimeOrderRel ψ φ) := by
exact Decidable.not_and_iff_or_not.mp hφψ
rcases hφψ with hφψ | hφψ
· rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel]
· rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel]
simp_all only [false_and, not_false_eq_true, false_or, mul_zero, zero_mul, map_zero]
simp_all
· rw [superCommute_ofCrAnState_ofCrAnState_symm]
· rw [superCommuteF_ofCrAnState_ofCrAnState_symm]
simp only [instCommGroup.eq_1, neg_smul, map_neg, map_smul, mul_neg, Algebra.mul_smul_comm,
neg_mul, Algebra.smul_mul_assoc, neg_eq_zero, smul_eq_zero]
rw [timeOrder_superCommute_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel]
rw [timeOrderF_superCommuteF_ofCrAnState_ofCrAnState_not_crAnTimeOrderRel]
simp only [mul_zero, zero_mul, map_zero, or_true]
simp_all
/-!
## Defining normal order for `FiedOpAlgebra`.
## Defining time order for `FiedOpAlgebra`.
-/
lemma ι_timeOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
lemma ι_timeOrderF_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
(h : a ∈ TwoSidedIdeal.span 𝓕.fieldOpIdealSet) : ι 𝓣ᶠ(a) = 0 := by
rw [TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure] at h
let p {k : Set 𝓕.CrAnAlgebra} (a : CrAnAlgebra 𝓕) (h : a ∈ AddSubgroup.closure k) := ι 𝓣ᶠ(a) = 0
@ -314,42 +314,42 @@ lemma ι_timeOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
match hc with
| Or.inl hc =>
obtain ⟨φa, φa', hφa, hφa', rfl⟩ := hc
simp only [ι_timeOrder_superCommute_superCommute]
simp only [ι_timeOrderF_superCommuteF_superCommuteF]
| Or.inr (Or.inl hc) =>
obtain ⟨φa, hφa, φb, hφb, rfl⟩ := hc
by_cases heqt : (crAnTimeOrderRel φa φb ∧ crAnTimeOrderRel φb φa)
· rw [ι_timeOrder_superCommute_eq_time]
· rw [ι_timeOrderF_superCommuteF_eq_time]
simp only [map_mul]
rw [ι_superCommute_of_create_create]
rw [ι_superCommuteF_of_create_create]
simp only [zero_mul]
· exact hφa
· exact hφb
· exact heqt.1
· exact heqt.2
· rw [ι_timeOrder_superCommute_neq_time heqt]
· rw [ι_timeOrderF_superCommuteF_neq_time heqt]
| Or.inr (Or.inr (Or.inl hc)) =>
obtain ⟨φa, hφa, φb, hφb, rfl⟩ := hc
by_cases heqt : (crAnTimeOrderRel φa φb ∧ crAnTimeOrderRel φb φa)
· rw [ι_timeOrder_superCommute_eq_time]
· rw [ι_timeOrderF_superCommuteF_eq_time]
simp only [map_mul]
rw [ι_superCommute_of_annihilate_annihilate]
rw [ι_superCommuteF_of_annihilate_annihilate]
simp only [zero_mul]
· exact hφa
· exact hφb
· exact heqt.1
· exact heqt.2
· rw [ι_timeOrder_superCommute_neq_time heqt]
· rw [ι_timeOrderF_superCommuteF_neq_time heqt]
| Or.inr (Or.inr (Or.inr hc)) =>
obtain ⟨φa, φb, hdiff, rfl⟩ := hc
by_cases heqt : (crAnTimeOrderRel φa φb ∧ crAnTimeOrderRel φb φa)
· rw [ι_timeOrder_superCommute_eq_time]
· rw [ι_timeOrderF_superCommuteF_eq_time]
simp only [map_mul]
rw [ι_superCommute_of_diff_statistic]
rw [ι_superCommuteF_of_diff_statistic]
simp only [zero_mul]
· exact hdiff
· exact heqt.1
· exact heqt.2
· rw [ι_timeOrder_superCommute_neq_time heqt]
· rw [ι_timeOrderF_superCommuteF_neq_time heqt]
· simp [p]
· intro x y hx hy
simp only [map_add, p]
@ -358,16 +358,16 @@ lemma ι_timeOrder_zero_of_mem_ideal (a : 𝓕.CrAnAlgebra)
· intro x hx
simp [p]
lemma ι_timeOrder_eq_of_equiv (a b : 𝓕.CrAnAlgebra) (h : a ≈ b) :
lemma ι_timeOrderF_eq_of_equiv (a b : 𝓕.CrAnAlgebra) (h : a ≈ b) :
ι 𝓣ᶠ(a) = ι 𝓣ᶠ(b) := by
rw [equiv_iff_sub_mem_ideal] at h
rw [LinearMap.sub_mem_ker_iff.mp]
simp only [LinearMap.mem_ker, ← map_sub]
exact ι_timeOrder_zero_of_mem_ideal (a - b) h
exact ι_timeOrderF_zero_of_mem_ideal (a - b) h
/-- Normal ordering on `FieldOpAlgebra`. -/
/-- Time ordering on `FieldOpAlgebra`. -/
noncomputable def timeOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where
toFun := Quotient.lift (ι.toLinearMap ∘ₗ CrAnAlgebra.timeOrder) ι_timeOrder_eq_of_equiv
toFun := Quotient.lift (ι.toLinearMap ∘ₗ timeOrderF) ι_timeOrderF_eq_of_equiv
map_add' x y := by
obtain ⟨x, hx⟩ := ι_surjective x
obtain ⟨y, hy⟩ := ι_surjective y
@ -381,5 +381,53 @@ noncomputable def timeOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra
rw [← map_smul, ι_apply, ι_apply]
simp
@[inherit_doc timeOrder]
scoped[FieldSpecification.FieldOpAlgebra] notation "𝓣(" a ")" => timeOrder a
/-!
## Properties of time ordering
-/
lemma timeOrder_eq_ι_timeOrderF (a : 𝓕.CrAnAlgebra) :
𝓣(ι a) = ι 𝓣ᶠ(a) := rfl
lemma timeOrder_ofFieldOp_ofFieldOp_ordered {φ ψ : 𝓕.States} (h : timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = ofFieldOp φ * ofFieldOp ψ := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
timeOrderF_ofState_ofState_ordered h]
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered {φ ψ : 𝓕.States} (h : ¬ timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • ofFieldOp ψ * ofFieldOp φ := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
timeOrderF_ofState_ofState_not_ordered h]
simp
lemma timeOrder_ofFieldOp_ofFieldOp_not_ordered_eq_timeOrder {φ ψ : 𝓕.States}
(h : ¬ timeOrderRel φ ψ) :
𝓣(ofFieldOp φ * ofFieldOp ψ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • 𝓣(ofFieldOp ψ * ofFieldOp φ) := by
rw [ofFieldOp, ofFieldOp, ← map_mul, timeOrder_eq_ι_timeOrderF,
timeOrderF_ofState_ofState_not_ordered_eq_timeOrderF h]
simp only [instCommGroup.eq_1, map_smul]
rfl
lemma timeOrder_ofFieldOpList_nil : 𝓣(ofFieldOpList (𝓕 := 𝓕) []) = 1 := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofStateList_nil]
simp
@[simp]
lemma timeOrder_ofFieldOpList_singleton (φ : 𝓕.States) :
𝓣(ofFieldOpList [φ]) = ofFieldOpList [φ] := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_ofStateList_singleton]
lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓣(ofFieldOpList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get,
(Finset.filter (fun x =>
(maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs) Finset.univ)⟩) •
ofFieldOp (maxTimeField φ φs) * 𝓣(ofFieldOpList (eraseMaxTimeField φ φs)) := by
rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_eq_maxTimeField_mul_finset]
rfl
end FieldOpAlgebra
end FieldSpecification

201
HepLean/PerturbationTheory/Algebras/ProtoOperatorAlgebra/Basic.lean
View file

@ -1,201 +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.Algebras.CrAnAlgebra.SuperCommute
/-!
# The operator algebras
-/
namespace FieldSpecification
variable (𝓕 : FieldSpecification)
open CrAnAlgebra
/--
A proto-operator algebra for a field specification `𝓕`
is a generalization of the operator algebra of a field theory with field specification `𝓕`.
It is an algebra `A` with a map `crAnF` from the creation and annihilation free algebra
satisfying a number of conditions with respect to super commutators.
The true operator algebra of a field theory with field specification `𝓕`is an
example of a proto-operator algebra. -/
structure ProtoOperatorAlgebra where
/-- The algebra representing the operator algebra. -/
A : Type
/-- The instance of the type `A` as a semi-ring. -/
[A_semiRing : Semiring A]
/-- The instance of the type `A` as an algebra. -/
[A_algebra : Algebra ℂ A]
/-- An algebra map from the creation and annihilation free algebra to the
algebra A. -/
crAnF : 𝓕.CrAnAlgebra →ₐ[ℂ] A
superCommute_crAn_center : ∀ (φ ψ : 𝓕.CrAnStates),
crAnF [ofCrAnState φ, ofCrAnState ψ]ₛca ∈ Subalgebra.center ℂ A
superCommute_create_create : ∀ (φc φc' : 𝓕.CrAnStates)
(_ : 𝓕 |>ᶜ φc = .create) (_ : 𝓕 |>ᶜ φc' = .create),
crAnF [ofCrAnState φc, ofCrAnState φc']ₛca = 0
superCommute_annihilate_annihilate : ∀ (φa φa' : 𝓕.CrAnStates)
(_ : 𝓕 |>ᶜ φa = .annihilate) (_ : 𝓕 |>ᶜ φa' = .annihilate),
crAnF [ofCrAnState φa, ofCrAnState φa']ₛca = 0
superCommute_different_statistics : ∀ (φ φ' : 𝓕.CrAnStates) (_ : ¬ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φ')),
crAnF [ofCrAnState φ, ofCrAnState φ']ₛca = 0
namespace ProtoOperatorAlgebra
open FieldStatistic
variable {𝓕 : FieldSpecification} (𝓞 : 𝓕.ProtoOperatorAlgebra)
/-- The algebra `𝓞.A` carries the instance of a semi-ring induced via `A_seimRing`. -/
instance : Semiring 𝓞.A := 𝓞.A_semiRing
/-- The algebra `𝓞.A` carries the instance of aan algebra over `ℂ` induced via `A_algebra`. -/
instance : Algebra ℂ 𝓞.A := 𝓞.A_algebra
lemma crAnF_superCommute_ofCrAnState_ofState_mem_center (φ : 𝓕.CrAnStates) (ψ : 𝓕.States) :
𝓞.crAnF [ofCrAnState φ, ofState ψ]ₛca ∈ Subalgebra.center ℂ 𝓞.A := by
rw [ofState, map_sum, map_sum]
refine Subalgebra.sum_mem (Subalgebra.center ℂ 𝓞.A) ?h
intro x _
exact 𝓞.superCommute_crAn_center φ ⟨ψ, x⟩
lemma crAnF_superCommute_anPart_ofState_mem_center (φ ψ : 𝓕.States) :
𝓞.crAnF [anPart φ, ofState ψ]ₛca ∈ Subalgebra.center ℂ 𝓞.A := by
match φ with
| States.inAsymp _ =>
simp only [anPart_negAsymp, map_zero, LinearMap.zero_apply]
exact Subalgebra.zero_mem (Subalgebra.center ℂ 𝓞.A)
| States.position φ =>
simp only [anPart_position]
exact 𝓞.crAnF_superCommute_ofCrAnState_ofState_mem_center _ _
| States.outAsymp _ =>
simp only [anPart_posAsymp]
exact 𝓞.crAnF_superCommute_ofCrAnState_ofState_mem_center _ _
lemma crAnF_superCommute_ofCrAnState_ofState_diff_grade_zero (φ : 𝓕.CrAnStates) (ψ : 𝓕.States)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
𝓞.crAnF [ofCrAnState φ, ofState ψ]ₛca = 0 := by
rw [ofState, map_sum, map_sum]
rw [Finset.sum_eq_zero]
intro x hx
apply 𝓞.superCommute_different_statistics
simpa [crAnStatistics] using h
lemma crAnF_superCommute_anPart_ofState_diff_grade_zero (φ ψ : 𝓕.States)
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
𝓞.crAnF [anPart φ, ofState ψ]ₛca = 0 := by
match φ with
| States.inAsymp _ =>
simp
| States.position φ =>
simp only [anPart_position]
apply 𝓞.crAnF_superCommute_ofCrAnState_ofState_diff_grade_zero _ _ _
simpa [crAnStatistics] using h
| States.outAsymp _ =>
simp only [anPart_posAsymp]
apply 𝓞.crAnF_superCommute_ofCrAnState_ofState_diff_grade_zero _ _
simpa [crAnStatistics] using h
lemma crAnF_superCommute_ofState_ofState_mem_center (φ ψ : 𝓕.States) :
𝓞.crAnF [ofState φ, ofState ψ]ₛca ∈ Subalgebra.center ℂ 𝓞.A := by
rw [ofState, map_sum]
simp only [LinearMap.coeFn_sum, Finset.sum_apply, map_sum]
refine Subalgebra.sum_mem (Subalgebra.center ℂ 𝓞.A) ?h
intro x _
exact crAnF_superCommute_ofCrAnState_ofState_mem_center 𝓞 ⟨φ, x⟩ ψ
lemma crAnF_superCommute_anPart_anPart (φ ψ : 𝓕.States) :
𝓞.crAnF [anPart φ, anPart ψ]ₛca = 0 := by
match φ, ψ with
| _, States.inAsymp _ =>
simp
| States.inAsymp _, _ =>
simp
| States.position φ, States.position ψ =>
simp only [anPart_position]
rw [𝓞.superCommute_annihilate_annihilate]
rfl
rfl
| States.position φ, States.outAsymp _ =>
simp only [anPart_position, anPart_posAsymp]
rw [𝓞.superCommute_annihilate_annihilate]
rfl
rfl
| States.outAsymp _, States.outAsymp _ =>
simp only [anPart_posAsymp]
rw [𝓞.superCommute_annihilate_annihilate]
rfl
rfl
| States.outAsymp _, States.position _ =>
simp only [anPart_posAsymp, anPart_position]
rw [𝓞.superCommute_annihilate_annihilate]
rfl
rfl
lemma crAnF_superCommute_crPart_crPart (φ ψ : 𝓕.States) :
𝓞.crAnF [crPart φ, crPart ψ]ₛca = 0 := by
match φ, ψ with
| _, States.outAsymp _ =>
simp
| States.outAsymp _, _ =>
simp
| States.position φ, States.position ψ =>
simp only [crPart_position]
rw [𝓞.superCommute_create_create]
rfl
rfl
| States.position φ, States.inAsymp _ =>
simp only [crPart_position, crPart_negAsymp]
rw [𝓞.superCommute_create_create]
rfl
rfl
| States.inAsymp _, States.inAsymp _ =>
simp only [crPart_negAsymp]
rw [𝓞.superCommute_create_create]
rfl
rfl
| States.inAsymp _, States.position _ =>
simp only [crPart_negAsymp, crPart_position]
rw [𝓞.superCommute_create_create]
rfl
rfl
lemma crAnF_superCommute_ofCrAnState_ofCrAnList_eq_sum (φ : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates) :
𝓞.crAnF [ofCrAnState φ, ofCrAnList φs]ₛca
= 𝓞.crAnF (∑ (n : Fin φs.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (List.take n φs)) •
[ofCrAnState φ, ofCrAnState (φs.get n)]ₛca * ofCrAnList (φs.eraseIdx n)) := by
conv_lhs =>
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_eq_sum]
rw [map_sum, map_sum]
congr
funext x
repeat rw [map_mul]
rw [map_smul, map_smul, ofCrAnList_singleton]
have h := Subalgebra.mem_center_iff.mp (𝓞.superCommute_crAn_center φ (φs.get x))
rw [h, mul_smul_comm, smul_mul_assoc, smul_mul_assoc, mul_assoc]
congr 1
· simp
· congr
rw [← map_mul, ← ofCrAnList_append, ← List.eraseIdx_eq_take_drop_succ]
lemma crAnF_superCommute_ofCrAnState_ofStateList_eq_sum (φ : 𝓕.CrAnStates) (φs : List 𝓕.States) :
𝓞.crAnF [ofCrAnState φ, ofStateList φs]ₛca
= 𝓞.crAnF (∑ (n : Fin φs.length), 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (List.take n φs)) •
[ofCrAnState φ, ofState (φs.get n)]ₛca * ofStateList (φs.eraseIdx n)) := by
conv_lhs =>
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofStateList_eq_sum]
rw [map_sum, map_sum]
congr
funext x
repeat rw [map_mul]
rw [map_smul, map_smul, ofCrAnList_singleton]
have h := Subalgebra.mem_center_iff.mp
(crAnF_superCommute_ofCrAnState_ofState_mem_center 𝓞 φ (φs.get x))
rw [h, mul_smul_comm, smul_mul_assoc, smul_mul_assoc, mul_assoc]
congr 1
· simp
· congr
rw [← map_mul, ← ofStateList_append, ← List.eraseIdx_eq_take_drop_succ]
end ProtoOperatorAlgebra
end FieldSpecification

413
HepLean/PerturbationTheory/Algebras/ProtoOperatorAlgebra/NormalOrder.lean
View file

@ -1,413 +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.Algebras.CrAnAlgebra.NormalOrder
import HepLean.PerturbationTheory.Koszul.KoszulSign
/-!
# Normal ordering of the operator algebra
-/
namespace FieldSpecification
variable {𝓕 : FieldSpecification}
namespace ProtoOperatorAlgebra
variable {𝓞 : ProtoOperatorAlgebra 𝓕}
open CrAnAlgebra
open FieldStatistic
/-!
## Normal order of super-commutators.
The main result of this section is
`crAnF_normalOrder_superCommute_eq_zero_mul`.
-/
lemma crAnF_normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList
(φc φc' : 𝓕.CrAnStates) (hφc : 𝓕 |>ᶜ φc = CreateAnnihilate.create)
(hφc' : 𝓕 |>ᶜ φc' = CreateAnnihilate.create) (φs φs' : List 𝓕.CrAnStates) :
𝓞.crAnF (𝓝ᶠ(ofCrAnList φs * [ofCrAnState φc, ofCrAnState φc']ₛca * ofCrAnList φs')) = 0 := by
rw [normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList φc φc' hφc hφc' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommute_create_create φc φc' hφc hφc']
simp
lemma crAnF_normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList
(φa φa' : 𝓕.CrAnStates) (hφa : 𝓕 |>ᶜ φa = CreateAnnihilate.annihilate)
(hφa' : 𝓕 |>ᶜ φa' = CreateAnnihilate.annihilate) (φs φs' : List 𝓕.CrAnStates) :
𝓞.crAnF (𝓝ᶠ(ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca * ofCrAnList φs')) = 0 := by
rw [normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommute_annihilate_annihilate φa φa' hφa hφa']
simp
lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
𝓞.crAnF (normalOrder
(ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca * ofCrAnList φ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'
· rw [normalOrder_superCommute_ofCrAnList_create_create_ofCrAnList φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommute_create_create φa φa' hφa hφa']
simp
· rw [normalOrder_superCommute_create_annihilate φa φa' hφa hφa' (ofCrAnList φs)
(ofCrAnList φs')]
simp
· rw [normalOrder_superCommute_annihilate_create φa' φa hφa' hφa (ofCrAnList φs)
(ofCrAnList φs')]
simp
· rw [normalOrder_superCommute_ofCrAnList_annihilate_annihilate_ofCrAnList φa φa' hφa hφa' φs φs']
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommute_annihilate_annihilate φa φa' hφa hφa']
simp
lemma crAnF_normalOrder_superCommute_ofCrAnList_eq_zero
(φa φa' : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates)
(a : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrder (ofCrAnList φs *
[ofCrAnState φa, ofCrAnState φa']ₛca * a)) = 0 := by
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap ((ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca))) a = 0
have hf : 𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap (ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca) = 0 := by
apply ofCrAnListBasis.ext
intro l
simp only [ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
AlgHom.toLinearMap_apply, LinearMap.zero_apply]
exact crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero φa φa' φs l
rw [hf]
simp
lemma crAnF_normalOrder_superCommute_ofCrAnState_eq_zero_mul (φa φa' : 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
𝓞.crAnF (normalOrder (a * [ofCrAnState φa, ofCrAnState φa']ₛca * b)) = 0 := by
rw [mul_assoc]
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ mulLinearMap.flip
([ofCrAnState φa, ofCrAnState φa']ₛca * b)) a = 0
have hf : 𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ mulLinearMap.flip
([ofCrAnState φa, ofCrAnState φa']ₛca * b) = 0 := by
apply ofCrAnListBasis.ext
intro l
simp only [mulLinearMap, ofListBasis_eq_ofList, LinearMap.coe_comp, Function.comp_apply,
LinearMap.flip_apply, LinearMap.coe_mk, AddHom.coe_mk, AlgHom.toLinearMap_apply,
LinearMap.zero_apply]
rw [← mul_assoc]
exact crAnF_normalOrder_superCommute_ofCrAnList_eq_zero φa φa' _ _
rw [hf]
simp
lemma crAnF_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
𝓞.crAnF (normalOrder (a * [ofCrAnState φa, ofCrAnList φs]ₛca * b)) = 0 := by
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_eq_sum]
rw [Finset.mul_sum, Finset.sum_mul]
rw [map_sum, map_sum]
apply Fintype.sum_eq_zero
intro n
rw [← mul_assoc, ← mul_assoc]
rw [mul_assoc _ _ b, ofCrAnList_singleton]
rw [crAnF_normalOrder_superCommute_ofCrAnState_eq_zero_mul]
lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul (φa : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
𝓞.crAnF (normalOrder (a * [ofCrAnList φs, ofCrAnState φa]ₛca * b)) = 0 := by
rw [← ofCrAnList_singleton, superCommute_ofCrAnList_ofCrAnList_symm, ofCrAnList_singleton]
simp only [FieldStatistic.instCommGroup.eq_1, FieldStatistic.ofList_singleton, mul_neg,
Algebra.mul_smul_comm, neg_mul, Algebra.smul_mul_assoc, map_neg, map_smul]
rw [crAnF_normalOrder_superCommute_ofCrAnState_ofCrAnList_eq_zero_mul]
simp
lemma crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul
(φs φs' : List 𝓕.CrAnStates)
(a b : 𝓕.CrAnAlgebra) :
𝓞.crAnF (normalOrder (a * [ofCrAnList φs, ofCrAnList φs']ₛca * b)) = 0 := by
rw [superCommute_ofCrAnList_ofCrAnList_eq_sum, Finset.mul_sum, Finset.sum_mul]
rw [map_sum, map_sum]
apply Fintype.sum_eq_zero
intro n
rw [← mul_assoc, ← mul_assoc]
rw [mul_assoc _ _ b]
rw [crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnState_eq_zero_mul]
lemma crAnF_normalOrder_superCommute_ofCrAnList_eq_zero_mul
(φs : List 𝓕.CrAnStates)
(a b c : 𝓕.CrAnAlgebra) :
𝓞.crAnF (normalOrder (a * [ofCrAnList φs, c]ₛca * b)) = 0 := by
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute (ofCrAnList φs)) c = 0
have hf : (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute (ofCrAnList φs)) = 0 := by
apply ofCrAnListBasis.ext
intro φs'
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
LinearMap.zero_apply]
rw [crAnF_normalOrder_superCommute_ofCrAnList_ofCrAnList_eq_zero_mul]
rw [hf]
simp
@[simp]
lemma crAnF_normalOrder_superCommute_eq_zero_mul
(a b c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrder (a * [d, c]ₛca * b)) = 0 := by
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute.flip c) d = 0
have hf : (𝓞.crAnF.toLinearMap ∘ₗ normalOrder ∘ₗ
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommute.flip c) = 0 := by
apply ofCrAnListBasis.ext
intro φs
simp only [mulLinearMap, LinearMap.coe_mk, AddHom.coe_mk, ofListBasis_eq_ofList,
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
LinearMap.zero_apply]
rw [crAnF_normalOrder_superCommute_ofCrAnList_eq_zero_mul]
rw [hf]
simp
@[simp]
lemma crAnF_normalOrder_superCommute_eq_zero_mul_right
(b c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrder ([d, c]ₛca * b)) = 0 := by
rw [← crAnF_normalOrder_superCommute_eq_zero_mul 1 b c d]
simp
@[simp]
lemma crAnF_normalOrder_superCommute_eq_zero_mul_left
(a c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrder (a * [d, c]ₛca)) = 0 := by
rw [← crAnF_normalOrder_superCommute_eq_zero_mul a 1 c d]
simp
@[simp]
lemma crAnF_normalOrder_superCommute_eq_zero
(c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrder [d, c]ₛca) = 0 := by
rw [← crAnF_normalOrder_superCommute_eq_zero_mul 1 1 c d]
simp
/-!
## Swapping terms in a normal order.
-/
lemma crAnF_normalOrder_ofState_ofState_swap (φ φ' : 𝓕.States) :
𝓞.crAnF (normalOrder (ofState φ * ofState φ')) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓞.crAnF (normalOrder (ofState φ' * ofState φ)) := by
rw [← ofStateList_singleton, ← ofStateList_singleton,
ofStateList_mul_ofStateList_eq_superCommute]
simp
lemma crAnF_normalOrder_ofCrAnState_ofCrAnList_swap (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) :
𝓞.crAnF (normalOrder (ofCrAnState φ * ofCrAnList φs)) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • 𝓞.crAnF (normalOrder (ofCrAnList φs * ofCrAnState φ)) := by
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommute]
simp
lemma crAnF_normalOrder_ofCrAnState_ofStatesList_swap (φ : 𝓕.CrAnStates)
(φ' : List 𝓕.States) :
𝓞.crAnF (normalOrder (ofCrAnState φ * ofStateList φ')) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓞.crAnF (normalOrder (ofStateList φ' * ofCrAnState φ)) := by
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofStateList_eq_superCommute]
simp
lemma crAnF_normalOrder_anPart_ofStatesList_swap (φ : 𝓕.States)
(φ' : List 𝓕.States) :
𝓞.crAnF (normalOrder (anPart φ * ofStateList φ')) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓞.crAnF (normalOrder (ofStateList φ' * anPart φ)) := by
match φ with
| .inAsymp φ =>
simp
| .position φ =>
simp only [anPart_position, instCommGroup.eq_1]
rw [crAnF_normalOrder_ofCrAnState_ofStatesList_swap]
rfl
| .outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1]
rw [crAnF_normalOrder_ofCrAnState_ofStatesList_swap]
rfl
lemma crAnF_normalOrder_ofStatesList_anPart_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
𝓞.crAnF (normalOrder (ofStateList φ' * anPart φ))
= 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓞.crAnF (normalOrder (anPart φ * ofStateList φ')) := by
rw [crAnF_normalOrder_anPart_ofStatesList_swap]
simp [smul_smul, FieldStatistic.exchangeSign_mul_self]
lemma crAnF_normalOrder_ofStatesList_mul_anPart_swap (φ : 𝓕.States)
(φ' : List 𝓕.States) :
𝓞.crAnF (normalOrder (ofStateList φ') * anPart φ) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
𝓞.crAnF (normalOrder (anPart φ * ofStateList φ')) := by
rw [← normalOrder_mul_anPart]
rw [crAnF_normalOrder_ofStatesList_anPart_swap]
/-!
## Super commutators with a normal ordered term as sums
-/
lemma crAnF_ofCrAnState_superCommute_normalOrder_ofCrAnList_eq_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.CrAnStates) : 𝓞.crAnF ([ofCrAnState φ, normalOrder (ofCrAnList φs)]ₛca) =
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
𝓞.crAnF ([ofCrAnState φ, ofCrAnState φs[n]]ₛca)
* 𝓞.crAnF (normalOrder (ofCrAnList (φs.eraseIdx n))) := by
rw [normalOrder_ofCrAnList, map_smul, map_smul]
rw [crAnF_superCommute_ofCrAnState_ofCrAnList_eq_sum, sum_normalOrderList_length]
simp only [instCommGroup.eq_1, List.get_eq_getElem, normalOrderList_get_normalOrderEquiv,
normalOrderList_eraseIdx_normalOrderEquiv, Algebra.smul_mul_assoc, map_sum, map_smul, map_mul,
Finset.smul_sum, Fin.getElem_fin]
congr
funext n
rw [ofCrAnList_eq_normalOrder, map_smul, mul_smul_comm, smul_smul, smul_smul]
by_cases hs : (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[n])
· congr
erw [normalOrderSign_eraseIdx, ← hs]
trans (normalOrderSign φs * normalOrderSign φs) *
(𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv n))) *
𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv n))))
* 𝓢(𝓕 |>ₛ (φs.get n), 𝓕 |>ₛ (φs.take n))
· ring_nf
rw [hs]
rfl
· simp [hs]
· erw [𝓞.superCommute_different_statistics _ _ hs]
simp
lemma crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum (φ : 𝓕.CrAnStates)
(φs : List 𝓕.States) : 𝓞.crAnF ([ofCrAnState φ, normalOrder (ofStateList φs)]ₛca) =
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
𝓞.crAnF ([ofCrAnState φ, ofState φs[n]]ₛca)
* 𝓞.crAnF (normalOrder (ofStateList (φs.eraseIdx n))) := by
conv_lhs =>
rw [ofStateList_sum, map_sum, map_sum, map_sum]
enter [2, s]
rw [crAnF_ofCrAnState_superCommute_normalOrder_ofCrAnList_eq_sum,
CrAnSection.sum_over_length]
enter [2, n]
rw [CrAnSection.take_statistics_eq_take_state_statistics, smul_mul_assoc]
rw [Finset.sum_comm]
refine Finset.sum_congr rfl (fun n _ => ?_)
simp only [instCommGroup.eq_1, Fin.coe_cast, Fin.getElem_fin,
CrAnSection.sum_eraseIdxEquiv n _ n.prop,
CrAnSection.eraseIdxEquiv_symm_getElem,
CrAnSection.eraseIdxEquiv_symm_eraseIdx, ← Finset.smul_sum, Algebra.smul_mul_assoc]
conv_lhs =>
enter [2, 2, n]
rw [← Finset.mul_sum]
rw [← Finset.sum_mul, ← map_sum, ← map_sum, ← ofState, ← map_sum, ← map_sum, ← ofStateList_sum]
/--
Within a proto-operator algebra we have that
`[anPart φ, 𝓝ᶠ(φs)] = ∑ i, sᵢ • [anPart φ, φᵢ]ₛca * 𝓝ᶠ(φ₀…φᵢ₋₁φᵢ₊₁…φₙ)`
where `sᵢ` is the exchange sign for `φ` and `φ₀…φᵢ₋₁`.
The origin of this result is
- `superCommute_ofCrAnList_ofCrAnList_eq_sum`
-/
lemma crAnF_anPart_superCommute_normalOrder_ofStateList_eq_sum (φ : 𝓕.States) (φs : List 𝓕.States) :
𝓞.crAnF ([anPart φ, 𝓝ᶠ(φs)]ₛca) =
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
𝓞.crAnF ([anPart φ, ofState φs[n]]ₛca) * 𝓞.crAnF 𝓝ᶠ(φs.eraseIdx n) := by
match φ with
| .inAsymp φ =>
simp
| .position φ =>
simp only [anPart_position, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
rw [crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum]
simp [crAnStatistics]
| .outAsymp φ =>
simp only [anPart_posAsymp, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
rw [crAnF_ofCrAnState_superCommute_normalOrder_ofStateList_eq_sum]
simp [crAnStatistics]
/-!
## Multiplying with normal ordered terms
-/
/--
Within a proto-operator algebra we have that
`anPart φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ((anPart φ)φ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
-/
lemma crAnF_anPart_mul_normalOrder_ofStatesList_eq_superCommute (φ : 𝓕.States)
(φ' : List 𝓕.States) :
𝓞.crAnF (anPart φ * normalOrder (ofStateList φ')) =
𝓞.crAnF (normalOrder (anPart φ * ofStateList φ')) +
𝓞.crAnF ([anPart φ, normalOrder (ofStateList φ')]ₛca) := by
rw [anPart_mul_normalOrder_ofStateList_eq_superCommute]
simp only [instCommGroup.eq_1, map_add, map_smul]
congr
rw [crAnF_normalOrder_anPart_ofStatesList_swap]
/--
Within a proto-operator algebra we have that
`φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ(φφ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
-/
lemma crAnF_ofState_mul_normalOrder_ofStatesList_eq_superCommute (φ : 𝓕.States)
(φs : List 𝓕.States) : 𝓞.crAnF (ofState φ * 𝓝ᶠ(φs)) =
𝓞.crAnF (normalOrder (ofState φ * ofStateList φs)) +
𝓞.crAnF ([anPart φ, 𝓝ᶠ(φs)]ₛca) := by
conv_lhs => rw [ofState_eq_crPart_add_anPart]
rw [add_mul, map_add, crAnF_anPart_mul_normalOrder_ofStatesList_eq_superCommute, ← add_assoc,
← normalOrder_crPart_mul, ← map_add]
conv_lhs =>
lhs
rw [← map_add, ← add_mul, ← ofState_eq_crPart_add_anPart]
/-- In the expansion of `ofState φ * normalOrder (ofStateList φs)` the element
of `𝓞.A` associated with contracting `φ` with the (optional) `n`th element of `φs`. -/
noncomputable def contractStateAtIndex (φ : 𝓕.States) (φs : List 𝓕.States)
(n : Option (Fin φs.length)) : 𝓞.A :=
match n with
| none => 1
| some n => 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
𝓞.crAnF ([anPart φ, ofState φs[n]]ₛca)
/--
Within a proto-operator algebra,
`φ * N(φ₀φ₁…φₙ) = N(φφ₀φ₁…φₙ) + ∑ i, (sᵢ • [anPart φ, φᵢ]ₛ) * N(φ₀φ₁…φᵢ₋₁φᵢ₊₁…φₙ)`,
where `sₙ` is the exchange sign for `φ` and `φ₀φ₁…φᵢ₋₁`.
-/
lemma crAnF_ofState_mul_normalOrder_ofStatesList_eq_sum (φ : 𝓕.States)
(φs : List 𝓕.States) :
𝓞.crAnF (ofState φ * normalOrder (ofStateList φs)) =
∑ n : Option (Fin φs.length),
contractStateAtIndex φ φs n *
𝓞.crAnF (normalOrder (ofStateList (HepLean.List.optionEraseZ φs φ n))) := by
rw [crAnF_ofState_mul_normalOrder_ofStatesList_eq_superCommute]
rw [crAnF_anPart_superCommute_normalOrder_ofStateList_eq_sum]
simp only [instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc, contractStateAtIndex,
Fintype.sum_option, one_mul]
rfl
/-!
## Cons vs insertIdx for a normal ordered term.
-/
/--
Within a proto-operator algebra, `N(φφ₀φ₁…φₙ) = s • N(φ₀…φₖ₋₁φφₖ…φₙ)`, where
`s` is the exchange sign for `φ` and `φ₀…φₖ₋₁`.
-/
lemma crAnF_ofState_normalOrder_insert (φ : 𝓕.States) (φs : List 𝓕.States)
(k : Fin φs.length.succ) :
𝓞.crAnF (normalOrder (ofStateList (φ :: φs))) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs.take k) • 𝓞.crAnF (normalOrder (ofStateList (φs.insertIdx k φ))) := by
have hl : φs.insertIdx k φ = φs.take k ++ [φ] ++ φs.drop k := by
rw [HepLean.List.insertIdx_eq_take_drop]
simp
rw [hl]
rw [ofStateList_append, ofStateList_append]
rw [ofStateList_mul_ofStateList_eq_superCommute, add_mul]
simp only [instCommGroup.eq_1, Nat.succ_eq_add_one, ofList_singleton, Algebra.smul_mul_assoc,
map_add, map_smul, crAnF_normalOrder_superCommute_eq_zero_mul_right, add_zero, smul_smul,
exchangeSign_mul_self_swap, one_smul]
rw [← ofStateList_append, ← ofStateList_append]
simp
end ProtoOperatorAlgebra
end FieldSpecification

89
HepLean/PerturbationTheory/Algebras/ProtoOperatorAlgebra/TimeContraction.lean
View file

@ -1,89 +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.Algebras.ProtoOperatorAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.CrAnAlgebra.TimeOrder
/-!
# Time contractions
We define the state algebra of a field structure to be the free algebra
generated by the states.
-/
namespace FieldSpecification
variable {𝓕 : FieldSpecification}
open CrAnAlgebra
noncomputable section
namespace ProtoOperatorAlgebra
variable (𝓞 : 𝓕.ProtoOperatorAlgebra)
open FieldStatistic
/-- The time contraction of two States 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) : 𝓞.A :=
𝓞.crAnF (𝓣ᶠ(ofState φ * ofState ψ) - 𝓝ᶠ(ofState φ * ofState ψ))
lemma timeContract_eq_smul (φ ψ : 𝓕.States) : 𝓞.timeContract φ ψ =
𝓞.crAnF (𝓣ᶠ(ofState φ * ofState ψ)
+ (-1 : ℂ) • 𝓝ᶠ(ofState φ * ofState ψ)) := by rfl
lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.States) (h : timeOrderRel φ ψ) :
𝓞.timeContract φ ψ = 𝓞.crAnF ([anPart φ, ofState ψ]ₛca) := by
conv_rhs =>
rw [ofState_eq_crPart_add_anPart]
rw [map_add, map_add, crAnF_superCommute_anPart_anPart, superCommute_anPart_crPart]
simp only [timeContract, instCommGroup.eq_1, Algebra.smul_mul_assoc, add_zero]
rw [timeOrder_ofState_ofState_ordered h]
rw [normalOrder_ofState_mul_ofState]
simp only [instCommGroup.eq_1]
rw [ofState_eq_crPart_add_anPart, ofState_eq_crPart_add_anPart]
simp only [mul_add, add_mul]
abel_nf
lemma timeContract_of_not_timeOrderRel (φ ψ : 𝓕.States) (h : ¬ timeOrderRel φ ψ) :
𝓞.timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • 𝓞.timeContract ψ φ := by
rw [timeContract_eq_smul]
simp only [Int.reduceNeg, one_smul, map_add]
rw [map_smul]
rw [crAnF_normalOrder_ofState_ofState_swap]
rw [timeOrder_ofState_ofState_not_ordered_eq_timeOrder h]
rw [timeContract_eq_smul]
simp only [instCommGroup.eq_1, map_smul, map_add, smul_add]
rw [smul_smul, smul_smul, mul_comm]
lemma timeContract_mem_center (φ ψ : 𝓕.States) : 𝓞.timeContract φ ψ ∈ Subalgebra.center ℂ 𝓞.A := by
by_cases h : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ _ h]
exact 𝓞.crAnF_superCommute_anPart_ofState_mem_center _ _
· rw [timeContract_of_not_timeOrderRel _ _ _ h]
refine Subalgebra.smul_mem (Subalgebra.center ℂ 𝓞.A) ?_ 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ)
rw [timeContract_of_timeOrderRel]
exact 𝓞.crAnF_superCommute_anPart_ofState_mem_center _ _
have h1 := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
lemma timeContract_zero_of_diff_grade (φ ψ : 𝓕.States) (h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
𝓞.timeContract φ ψ = 0 := by
by_cases h1 : timeOrderRel φ ψ
· rw [timeContract_of_timeOrderRel _ _ _ h1]
rw [crAnF_superCommute_anPart_ofState_diff_grade_zero]
exact h
· rw [timeContract_of_not_timeOrderRel _ _ _ h1]
rw [timeContract_of_timeOrderRel _ _ _]
rw [crAnF_superCommute_anPart_ofState_diff_grade_zero]
simp only [instCommGroup.eq_1, smul_zero]
exact h.symm
have ht := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ
simp_all
end ProtoOperatorAlgebra
end
end FieldSpecification

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

@ -3,8 +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.Algebras.ProtoOperatorAlgebra.Basic
import HepLean.PerturbationTheory.Koszul.KoszulSign
import HepLean.PerturbationTheory.FieldSpecification.CrAnStates
/-!
# Filters of lists of CrAnStates

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

@ -3,9 +3,8 @@ Copyright (c) 2025 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.PerturbationTheory.Algebras.ProtoOperatorAlgebra.Basic
import HepLean.PerturbationTheory.Koszul.KoszulSign
import HepLean.PerturbationTheory.FieldSpecification.Filters
import HepLean.PerturbationTheory.Koszul.KoszulSign
/-!
# Normal Ordering of states

2
HepLean/PerturbationTheory/FieldSpecification/TimeOrder.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.Mathematics.List.InsertionSort
import HepLean.PerturbationTheory.FieldSpecification.CrAnSection
import HepLean.PerturbationTheory.FieldSpecification.NormalOrder
/-!

2
HepLean/PerturbationTheory/WickContraction/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.Algebras.ProtoOperatorAlgebra.NormalOrder
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.NormalOrder
import HepLean.Mathematics.List.InsertIdx
/-!

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

@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
import HepLean.PerturbationTheory.WickContraction.Sign
import HepLean.PerturbationTheory.Algebras.ProtoOperatorAlgebra.TimeContraction
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.TimeContraction
/-!
# Time contractions
@ -17,16 +17,16 @@ variable {𝓕 : FieldSpecification}
namespace WickContraction
variable {n : ℕ} (c : WickContraction n)
open HepLean.List
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 (𝓞 : 𝓕.ProtoOperatorAlgebra) {φs : List 𝓕.States}
noncomputable def timeContract {φs : List 𝓕.States}
(φsΛ : WickContraction φs.length) :
Subalgebra.center ℂ 𝓞.A :=
∏ (a : φsΛ.1), ⟨𝓞.timeContract
Subalgebra.center ℂ 𝓕.FieldOpAlgebra :=
∏ (a : φsΛ.1), ⟨FieldOpAlgebra.timeContract
(φs.get (φsΛ.fstFieldOfContract a)) (φs.get (φsΛ.sndFieldOfContract a)),
𝓞.timeContract_mem_center _ _⟩
timeContract_mem_center _ _⟩
/-- For `φsΛ` a Wick contraction for `φs`, the time contraction `(φsΛ ↩Λ φ i none).timeContract 𝓞`
is equal to `φsΛ.timeContract 𝓞`.
@ -34,10 +34,10 @@ noncomputable def timeContract (𝓞 : 𝓕.ProtoOperatorAlgebra) {φs : List
This result follows from the fact that `timeContract` only depends on contracted pairs,
and `(φsΛ ↩Λ φ i none)` has the 'same' contracted pairs as `φsΛ`. -/
@[simp]
lemma timeContract_insertAndContract_none (𝓞 : 𝓕.ProtoOperatorAlgebra)
lemma timeContract_insertAndContract_none
(φ : 𝓕.States) (φs : List 𝓕.States)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) :
(φsΛ ↩Λ φ i none).timeContract 𝓞 = φsΛ.timeContract 𝓞 := by
(φsΛ ↩Λ φ i none).timeContract = φsΛ.timeContract := by
rw [timeContract, insertAndContract_none_prod_contractions]
congr
ext a
@ -51,13 +51,14 @@ lemma timeContract_insertAndContract_none (𝓞 : 𝓕.ProtoOperatorAlgebra)
This follows from the fact that `(φsΛ ↩Λ φ i (some j))` has one more contracted pair than `φsΛ`,
corresponding to `φ` contracted with `φⱼ`. The order depends on whether we insert `φ` before
or after `φⱼ`. -/
lemma timeConract_insertAndContract_some (𝓞 : 𝓕.ProtoOperatorAlgebra)
lemma timeConract_insertAndContract_some
(φ : 𝓕.States) (φs : List 𝓕.States)
(φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) :
(φsΛ ↩Λ φ i (some j)).timeContract 𝓞 =
(φsΛ ↩Λ φ i (some j)).timeContract =
(if i < i.succAbove j then
⟨𝓞.timeContract φ φs[j.1], 𝓞.timeContract_mem_center _ _⟩
else ⟨𝓞.timeContract φs[j.1] φ, 𝓞.timeContract_mem_center _ _⟩) * φsΛ.timeContract 𝓞 := by
⟨FieldOpAlgebra.timeContract φ φs[j.1], timeContract_mem_center _ _⟩
else ⟨FieldOpAlgebra.timeContract φs[j.1] φ, timeContract_mem_center _ _⟩) *
φsΛ.timeContract := by
rw [timeContract, insertAndContract_some_prod_contractions]
congr 1
· simp only [Nat.succ_eq_add_one, insertAndContract_fstFieldOfContract_some_incl, finCongr_apply,
@ -72,27 +73,25 @@ lemma timeConract_insertAndContract_some (𝓞 : 𝓕.ProtoOperatorAlgebra)
open FieldStatistic
lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
(𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ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Λ ↩Λ φ i (some k)).timeContract =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < k))⟩)
• (𝓞.contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedStatesEquiv φs φsΛ) (some k)) *
φsΛ.timeContract 𝓞) := by
• (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedStatesEquiv φ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,
ProtoOperatorAlgebra.contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast,
List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem,
Algebra.smul_mul_assoc, uncontractedListGet]
· simp only [hik, ↓reduceIte, MulMemClass.coe_mul]
rw [𝓞.timeContract_of_timeOrderRel]
trans (1 : ℂ) • (𝓞.crAnF ((CrAnAlgebra.superCommute
(CrAnAlgebra.anPart φ)) (CrAnAlgebra.ofState φs[k.1])) *
↑(timeContract 𝓞 φsΛ))
rw [timeContract_of_timeOrderRel]
trans (1 : ℂ) • ((superCommute (anPart φ)) (ofFieldOp φs[k.1]) * ↑φsΛ.timeContract)
· simp
simp only [smul_smul]
congr
congr 1
have h1 : ofList 𝓕.statesStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k))
(List.map φs.get φsΛ.uncontractedList))
= (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) φsΛ.uncontracted)⟩) := by
@ -107,21 +106,21 @@ lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt
· exact ht
lemma timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_not_lt
(𝓞 : 𝓕.ProtoOperatorAlgebra) (φ : 𝓕.States) (φs : List 𝓕.States)
(φ : 𝓕.States) (φs : List 𝓕.States)
(φ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Λ ↩Λ φ i (some k)).timeContract =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x ≤ k))⟩)
• (𝓞.contractStateAtIndex φ [φsΛ]ᵘᶜ
((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract 𝓞) := by
• (contractStateAtIndex φ [φsΛ]ᵘᶜ
((uncontractedStatesEquiv φ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,
ProtoOperatorAlgebra.contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
contractStateAtIndex, uncontractedStatesEquiv, Equiv.optionCongr_apply,
Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast,
List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem,
Algebra.smul_mul_assoc, uncontractedListGet]
simp only [hik, ↓reduceIte, MulMemClass.coe_mul]
rw [𝓞.timeContract_of_not_timeOrderRel, 𝓞.timeContract_of_timeOrderRel]
rw [timeContract_of_not_timeOrderRel, timeContract_of_timeOrderRel]
simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, smul_smul]
congr
have h1 : ofList 𝓕.statesStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k))
@ -158,9 +157,9 @@ 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 (𝓞 : 𝓕.ProtoOperatorAlgebra) (φs : List 𝓕.States)
lemma timeContract_of_not_gradingCompliant (φs : List 𝓕.States)
(φsΛ : WickContraction φs.length) (h : ¬ GradingCompliant φs φsΛ) :
φsΛ.timeContract 𝓞 = 0 := by
φsΛ.timeContract = 0 := by
rw [timeContract]
simp only [GradingCompliant, Fin.getElem_fin, Subtype.forall, not_forall] at h
obtain ⟨a, ha⟩ := h
@ -169,7 +168,7 @@ lemma timeContract_of_not_gradingCompliant (𝓞 : 𝓕.ProtoOperatorAlgebra) (
simp only [Finset.univ_eq_attach, Finset.mem_attach]
apply Subtype.eq
simp only [List.get_eq_getElem, ZeroMemClass.coe_zero]
rw [ProtoOperatorAlgebra.timeContract_zero_of_diff_grade]
rw [timeContract_zero_of_diff_grade]
simp [ha2]
end WickContraction

96
HepLean/PerturbationTheory/WicksTheorem.lean
View file

@ -17,9 +17,9 @@ Wick's theorem is related to Isserlis' theorem in mathematics.
-/
namespace FieldSpecification
variable {𝓕 : FieldSpecification} {𝓞 : 𝓕.ProtoOperatorAlgebra}
variable {𝓕 : FieldSpecification}
open CrAnAlgebra
open ProtoOperatorAlgebra
open FieldOpAlgebra
open HepLean.List
open WickContraction
open FieldStatistic
@ -37,13 +37,13 @@ Where `s` is the exchange sign for `φ` and the uncontracted fields in `φ₀φ
-/
lemma normalOrder_uncontracted_none (φ : 𝓕.States) (φs : List 𝓕.States)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
𝓞.crAnF (𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ))
𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ)
= 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => i.succAbove x < i)⟩) •
𝓞.crAnF 𝓝ᶠ(φ :: [φsΛ]ᵘᶜ) := by
𝓝(ofFieldOpList (φ :: [φsΛ]ᵘᶜ)) := by
simp only [Nat.succ_eq_add_one, instCommGroup.eq_1]
rw [crAnF_ofState_normalOrder_insert φ [φsΛ]ᵘᶜ
rw [ofFieldOpList_normalOrder_insert φ [φsΛ]ᵘᶜ
⟨(φsΛ.uncontractedListOrderPos i), by simp [uncontractedListGet]⟩, smul_smul]
trans (1 : ℂ) • 𝓞.crAnF (𝓝ᶠ(ofStateList [φsΛ ↩Λ φ i none]ᵘᶜ))
trans (1 : ℂ) • (𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ))
· simp
congr 1
simp only [instCommGroup.eq_1, uncontractedListGet]
@ -107,8 +107,8 @@ where `k'` is the position in `c.uncontractedList` corresponding to `k`.
-/
lemma normalOrder_uncontracted_some (φ : 𝓕.States) (φs : List 𝓕.States)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) :
𝓞.crAnF 𝓝ᶠ([φsΛ ↩Λ φ i (some k)]ᵘᶜ)
= 𝓞.crAnF 𝓝ᶠ((optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedStatesEquiv φs φsΛ) k))) := by
𝓝(ofFieldOpList [φsΛ ↩Λ φ i (some k)]ᵘᶜ)
= 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedStatesEquiv φs φsΛ) k))) := by
simp only [Nat.succ_eq_add_one, insertAndContract, optionEraseZ, uncontractedStatesEquiv,
Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply,
Fin.coe_cast, uncontractedListGet]
@ -143,7 +143,7 @@ is equal to
where `s` is the exchange sign of `φ` and the uncontracted fields in `φ₀φ₁…φᵢ₋₁`.
The proof of this result relies primarily on:
- `normalOrder_uncontracted_none` which replaces `𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ)` with
- `normalOrderF_uncontracted_none` which replaces `𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ)` with
`𝓝ᶠ(φ :: [φsΛ]ᵘᶜ)` up to a sign.
- `timeContract_insertAndContract_none` which replaces `(φsΛ ↩Λ φ i none).timeContract 𝓞` with
`φsΛ.timeContract 𝓞`.
@ -152,10 +152,10 @@ The proof of this result relies primarily on:
-/
lemma wick_term_none_eq_wick_term_cons (φ : 𝓕.States) (φs : List 𝓕.States)
(i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) :
(φsΛ ↩Λ φ i none).sign • (φsΛ ↩Λ φ i none).timeContract 𝓞
* 𝓞.crAnF 𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ) =
(φsΛ ↩Λ φ i none).sign • (φsΛ ↩Λ φ i none).timeContract
* 𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun k => i.succAbove k < i))⟩)
• (φsΛ.sign • φsΛ.timeContract 𝓞 * 𝓞.crAnF 𝓝ᶠ(φ :: [φsΛ]ᵘᶜ)) := by
• (φsΛ.sign • φsΛ.timeContract * 𝓝(ofFieldOpList (φ :: [φsΛ]ᵘᶜ))) := by
by_cases hg : GradingCompliant φs φsΛ
· rw [normalOrder_uncontracted_none, sign_insert_none]
simp only [Nat.succ_eq_add_one, timeContract_insertAndContract_none, instCommGroup.eq_1,
@ -202,12 +202,12 @@ lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List
(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] φ) :
(φsΛ ↩Λ φ i (some k)).sign • (φsΛ ↩Λ φ i (some k)).timeContract 𝓞
* 𝓞.crAnF 𝓝ᶠ([φsΛ ↩Λ φ i (some k)]ᵘᶜ) =
(φsΛ ↩Λ φ i (some k)).sign • (φsΛ ↩Λ φ i (some k)).timeContract
* 𝓝(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 𝓞)
* 𝓞.crAnF 𝓝ᶠ((optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedStatesEquiv φs φsΛ k)))) := by
• (φsΛ.sign • (contractStateAtIndex φ [φsΛ]ᵘᶜ
((uncontractedStatesEquiv φs φsΛ) (some k)) * φsΛ.timeContract)
* 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedStatesEquiv φs φsΛ k)))) := by
by_cases hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[k.1])
· by_cases hk : i.succAbove k < i
· rw [WickContraction.timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_not_lt]
@ -245,14 +245,14 @@ lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List
· simp only [h1, ↓reduceIte, MulMemClass.coe_mul]
rw [timeContract_zero_of_diff_grade]
simp only [zero_mul, smul_zero]
rw [crAnF_superCommute_anPart_ofState_diff_grade_zero]
rw [superCommute_anPart_ofState_diff_grade_zero]
simp only [zero_mul, smul_zero]
exact hg
exact hg
· simp only [h1, ↓reduceIte, MulMemClass.coe_mul]
rw [timeContract_zero_of_diff_grade]
simp only [zero_mul, smul_zero]
rw [crAnF_superCommute_anPart_ofState_diff_grade_zero]
rw [superCommute_anPart_ofState_diff_grade_zero]
simp only [zero_mul, smul_zero]
exact hg
exact fun a => hg (id (Eq.symm a))
@ -270,18 +270,18 @@ is equal to the product of
over all `k` in `Option φsΛ.uncontracted`.
The proof of this result primarily depends on
- `crAnF_ofState_mul_normalOrder_ofStatesList_eq_sum` to rewrite `𝓞.crAnF (φ * 𝓝ᶠ([φsΛ]ᵘᶜ))`
- `crAnF_ofState_mul_normalOrderF_ofStatesList_eq_sum` to rewrite `𝓞.crAnF (φ * 𝓝ᶠ([φsΛ]ᵘᶜ))`
- `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)
(φ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 𝓞) * 𝓞.crAnF ((CrAnAlgebra.ofState φ) * 𝓝ᶠ([φsΛ]ᵘᶜ)) =
(φsΛ.sign • φsΛ.timeContract) * ((ofFieldOp φ) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)) =
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩) •
∑ (k : Option φsΛ.uncontracted), ((φsΛ ↩Λ φ i k).sign •
(φsΛ ↩Λ φ i k).timeContract 𝓞 * 𝓞.crAnF (𝓝ᶠ([φsΛ ↩Λ φ i k]ᵘᶜ))) := by
rw [crAnF_ofState_mul_normalOrder_ofStatesList_eq_sum, Finset.mul_sum,
(φ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]
simp only [instCommGroup.eq_1, Nat.succ_eq_add_one]
congr 1
@ -305,7 +305,7 @@ lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.States) (φs : List 𝓕.States
rw [one_mul]
· rw [← mul_assoc]
congr 1
have ht := (WickContraction.timeContract 𝓞 φsΛ).prop
have ht := (WickContraction.timeContract φsΛ).prop
rw [@Subalgebra.mem_center_iff] at ht
rw [ht]
@ -317,21 +317,25 @@ lemma wick_term_cons_eq_sum_wick_term (φ : 𝓕.States) (φs : List 𝓕.States
/-- Wick's theorem for the empty list. -/
lemma wicks_theorem_nil :
𝓞.crAnF (𝓣ᶠ(ofStateList [])) = ∑ (nilΛ : WickContraction [].length),
(nilΛ.sign • nilΛ.timeContract 𝓞) * 𝓞.crAnF 𝓝ᶠ([nilΛ]ᵘᶜ) := by
rw [timeOrder_ofStateList_nil]
𝓣(ofFieldOpList (𝓕 := 𝓕) []) = ∑ (nilΛ : WickContraction [].length),
(nilΛ.sign (𝓕 := 𝓕) • nilΛ.timeContract) * 𝓝(ofFieldOpList [nilΛ]ᵘᶜ) := by
rw [timeOrder_ofFieldOpList_nil]
simp only [map_one, List.length_nil, Algebra.smul_mul_assoc]
rw [sum_WickContraction_nil, uncontractedListGet, nil_zero_uncontractedList]
simp only [List.map_nil]
have h1 : ofStateList (𝓕 := 𝓕) [] = CrAnAlgebra.ofCrAnList [] := by simp
rw [h1, normalOrder_ofCrAnList]
simp [WickContraction.timeContract, empty, sign]
have h1 : ofFieldOpList (𝓕 := 𝓕) [] = ofCrAnFieldOpList [] := by
rw [ofFieldOpList, ofCrAnFieldOpList]
simp
rw [h1, normalOrder_ofCrAnFieldOpList]
simp only [sign, List.length_nil, empty, Finset.univ_eq_empty, instCommGroup.eq_1,
Fin.getElem_fin, Finset.prod_empty, WickContraction.timeContract, List.get_eq_getElem,
OneMemClass.coe_one, normalOrderSign_nil, normalOrderList_nil, one_smul, one_mul]
rfl
lemma wicks_theorem_congr {φs φs' : List 𝓕.States} (h : φs = φs') :
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract 𝓞) *
𝓞.crAnF 𝓝ᶠ([φsΛ]ᵘᶜ)
= ∑ (φs'Λ : WickContraction φs'.length), (φs'Λ.sign • φs'Λ.timeContract 𝓞) *
𝓞.crAnF 𝓝ᶠ([φs'Λ]ᵘᶜ) := by
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)
= ∑ (φs'Λ : WickContraction φs'.length), (φs'Λ.sign • φs'Λ.timeContract) *
𝓝(ofFieldOpList [φs'Λ]ᵘᶜ) := by
subst h
simp
@ -351,31 +355,31 @@ 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) → 𝓞.crAnF (𝓣ᶠ(ofStateList φs)) =
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract 𝓞) * 𝓞.crAnF 𝓝ᶠ([φsΛ]ᵘᶜ)
theorem wicks_theorem : (φs : List 𝓕.States) → 𝓣(ofFieldOpList φs) =
∑ (φsΛ : WickContraction φs.length), (φsΛ.sign • φsΛ.timeContract) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)
| [] => wicks_theorem_nil
| φ :: φs => by
have ih := wicks_theorem (eraseMaxTimeField φ φs)
rw [timeOrder_eq_maxTimeField_mul_finset, map_mul, ih, Finset.mul_sum]
conv_lhs => rw [timeOrder_eq_maxTimeField_mul_finset, ih, Finset.mul_sum]
have h1 : φ :: φs =
(eraseMaxTimeField φ φs).insertIdx (maxTimeFieldPosFin φ φs) (maxTimeField φ φs) := by
simp only [eraseMaxTimeField, insertionSortDropMinPos, List.length_cons, Nat.succ_eq_add_one,
maxTimeField, insertionSortMin, List.get_eq_getElem]
erw [insertIdx_eraseIdx_fin]
rw [wicks_theorem_congr h1]
conv_rhs => rw [wicks_theorem_congr h1]
conv_rhs => rw [insertLift_sum]
congr
funext c
have ht := Subalgebra.mem_center_iff.mp (Subalgebra.smul_mem (Subalgebra.center ℂ 𝓞.A)
(WickContraction.timeContract 𝓞 c).2 (sign (eraseMaxTimeField φ φs) c))
rw [map_smul, Algebra.smul_mul_assoc, ← mul_assoc, ht, mul_assoc, ← map_mul]
rw [wick_term_cons_eq_sum_wick_term (𝓞 := 𝓞)
apply Finset.sum_congr rfl
intro c _
have ht := Subalgebra.mem_center_iff.mp (Subalgebra.smul_mem (Subalgebra.center ℂ _)
(WickContraction.timeContract c).2 (sign (eraseMaxTimeField φ φs) c))
rw [Algebra.smul_mul_assoc, ← mul_assoc, ht, mul_assoc]
rw [wick_term_cons_eq_sum_wick_term
(maxTimeField φ φs) (eraseMaxTimeField φ φs) (maxTimeFieldPosFin φ φs) c]
trans (1 : ℂ) • ∑ k : Option { x // x ∈ c.uncontracted }, sign
(List.insertIdx (↑(maxTimeFieldPosFin φ φs)) (maxTimeField φ φs) (eraseMaxTimeField φ φs))
(c ↩Λ (maxTimeField φ φs) (maxTimeFieldPosFin φ φs) k) •
↑((c ↩Λ (maxTimeField φ φs) (maxTimeFieldPosFin φ φs) k).timeContract 𝓞) *
𝓞.crAnF 𝓝ᶠ(ofStateList (List.map (List.insertIdx (↑(maxTimeFieldPosFin φ φs))
↑((c ↩Λ (maxTimeField φ φs) (maxTimeFieldPosFin φ φs) k).timeContract) *
𝓝(ofFieldOpList (List.map (List.insertIdx (↑(maxTimeFieldPosFin φ φs))
(maxTimeField φ φs) (eraseMaxTimeField φ φs)).get
(c ↩Λ (maxTimeField φ φs) (maxTimeFieldPosFin φ φs) k).uncontractedList))
swap