refactor: Remove ProtoOperatorAlgebra
This commit is contained in:
jstoobysmith
parent
c18b4850e5
commit
fc20099282
15 changed files with 615 additions and 792 deletions
|
|
@ -131,9 +131,6 @@ import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.Basic
|
|||
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.NormalOrder
|
||||
import HepLean.PerturbationTheory.Algebras.FieldOpAlgebra.SuperCommute
|
||||
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
|
||||
|
|
|
|||
|
|
@ -439,12 +439,28 @@ def ofFieldOpList (φs : List 𝓕.States) : 𝓕.FieldOpAlgebra := ι (ofStateL
|
|||
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)
|
||||
|
||||
|
|
@ -461,6 +477,12 @@ 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 φ)
|
||||
|
||||
|
|
@ -503,5 +525,10 @@ 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
|
||||
|
|
|
|||
|
|
@ -243,6 +243,33 @@ scoped[FieldSpecification.FieldOpAlgebra] notation "𝓝(" a ")" => normalOrder
|
|||
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
|
||||
|
|
@ -286,5 +313,252 @@ lemma normalOrder_superCommute_mid_eq_zero (a b c d : 𝓕.FieldOpAlgebra) :
|
|||
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
|
||||
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
|
||||
|
|
|
|||
|
|
@ -147,11 +147,66 @@ lemma superCommute_diff_statistic {φ φ' : 𝓕.CrAnStates} (h : (𝓕 |>ₛ φ
|
|||
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
|
||||
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.
|
||||
|
|
@ -336,6 +391,13 @@ lemma ofFieldOp_mul_ofFieldOpList_eq_superCommute (φ : 𝓕.States) (φs' : Lis
|
|||
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
|
||||
|
|
@ -412,6 +474,22 @@ lemma superCommute_ofCrAnFieldOpList_ofCrAnFieldOpList_eq_sum (φs φs' : List
|
|||
rw [map_sum]
|
||||
rfl
|
||||
|
||||
lemma superCommute_ofCrAnFieldOp_ofCrAnFieldOpList_eq_sum (φ : 𝓕.CrAnStates) (φs' : List 𝓕.CrAnStates) :
|
||||
[ofCrAnFieldOp φ, ofCrAnFieldOpList φs']ₛ =
|
||||
∑ (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
|
||||
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) •
|
||||
|
|
@ -423,6 +501,20 @@ lemma superCommute_ofCrAnFieldOpList_ofFieldOpList_eq_sum (φs : List 𝓕.CrAnS
|
|||
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
|
||||
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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
superCommuteF_crAn_center : ∀ (φ ψ : 𝓕.CrAnStates),
|
||||
crAnF [ofCrAnState φ, ofCrAnState ψ]ₛca ∈ Subalgebra.center ℂ A
|
||||
superCommuteF_create_create : ∀ (φc φc' : 𝓕.CrAnStates)
|
||||
(_ : 𝓕 |>ᶜ φc = .create) (_ : 𝓕 |>ᶜ φc' = .create),
|
||||
crAnF [ofCrAnState φc, ofCrAnState φc']ₛca = 0
|
||||
superCommuteF_annihilate_annihilate : ∀ (φa φa' : 𝓕.CrAnStates)
|
||||
(_ : 𝓕 |>ᶜ φa = .annihilate) (_ : 𝓕 |>ᶜ φa' = .annihilate),
|
||||
crAnF [ofCrAnState φa, ofCrAnState φa']ₛca = 0
|
||||
superCommuteF_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_superCommuteF_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 𝓞.superCommuteF_crAn_center φ ⟨ψ, x⟩
|
||||
|
||||
lemma crAnF_superCommuteF_anPartF_ofState_mem_center (φ ψ : 𝓕.States) :
|
||||
𝓞.crAnF [anPartF φ, ofState ψ]ₛca ∈ Subalgebra.center ℂ 𝓞.A := by
|
||||
match φ with
|
||||
| States.inAsymp _ =>
|
||||
simp only [anPartF_negAsymp, map_zero, LinearMap.zero_apply]
|
||||
exact Subalgebra.zero_mem (Subalgebra.center ℂ 𝓞.A)
|
||||
| States.position φ =>
|
||||
simp only [anPartF_position]
|
||||
exact 𝓞.crAnF_superCommuteF_ofCrAnState_ofState_mem_center _ _
|
||||
| States.outAsymp _ =>
|
||||
simp only [anPartF_posAsymp]
|
||||
exact 𝓞.crAnF_superCommuteF_ofCrAnState_ofState_mem_center _ _
|
||||
|
||||
lemma crAnF_superCommuteF_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 𝓞.superCommuteF_different_statistics
|
||||
simpa [crAnStatistics] using h
|
||||
|
||||
lemma crAnF_superCommuteF_anPartF_ofState_diff_grade_zero (φ ψ : 𝓕.States)
|
||||
(h : (𝓕 |>ₛ φ) ≠ (𝓕 |>ₛ ψ)) :
|
||||
𝓞.crAnF [anPartF φ, ofState ψ]ₛca = 0 := by
|
||||
match φ with
|
||||
| States.inAsymp _ =>
|
||||
simp
|
||||
| States.position φ =>
|
||||
simp only [anPartF_position]
|
||||
apply 𝓞.crAnF_superCommuteF_ofCrAnState_ofState_diff_grade_zero _ _ _
|
||||
simpa [crAnStatistics] using h
|
||||
| States.outAsymp _ =>
|
||||
simp only [anPartF_posAsymp]
|
||||
apply 𝓞.crAnF_superCommuteF_ofCrAnState_ofState_diff_grade_zero _ _
|
||||
simpa [crAnStatistics] using h
|
||||
|
||||
lemma crAnF_superCommuteF_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_superCommuteF_ofCrAnState_ofState_mem_center 𝓞 ⟨φ, x⟩ ψ
|
||||
|
||||
lemma crAnF_superCommuteF_anPartF_anPartF (φ ψ : 𝓕.States) :
|
||||
𝓞.crAnF [anPartF φ, anPartF ψ]ₛca = 0 := by
|
||||
match φ, ψ with
|
||||
| _, States.inAsymp _ =>
|
||||
simp
|
||||
| States.inAsymp _, _ =>
|
||||
simp
|
||||
| States.position φ, States.position ψ =>
|
||||
simp only [anPartF_position]
|
||||
rw [𝓞.superCommuteF_annihilate_annihilate]
|
||||
rfl
|
||||
rfl
|
||||
| States.position φ, States.outAsymp _ =>
|
||||
simp only [anPartF_position, anPartF_posAsymp]
|
||||
rw [𝓞.superCommuteF_annihilate_annihilate]
|
||||
rfl
|
||||
rfl
|
||||
| States.outAsymp _, States.outAsymp _ =>
|
||||
simp only [anPartF_posAsymp]
|
||||
rw [𝓞.superCommuteF_annihilate_annihilate]
|
||||
rfl
|
||||
rfl
|
||||
| States.outAsymp _, States.position _ =>
|
||||
simp only [anPartF_posAsymp, anPartF_position]
|
||||
rw [𝓞.superCommuteF_annihilate_annihilate]
|
||||
rfl
|
||||
rfl
|
||||
|
||||
lemma crAnF_superCommuteF_crPartF_crPartF (φ ψ : 𝓕.States) :
|
||||
𝓞.crAnF [crPartF φ, crPartF ψ]ₛca = 0 := by
|
||||
match φ, ψ with
|
||||
| _, States.outAsymp _ =>
|
||||
simp
|
||||
| States.outAsymp _, _ =>
|
||||
simp
|
||||
| States.position φ, States.position ψ =>
|
||||
simp only [crPartF_position]
|
||||
rw [𝓞.superCommuteF_create_create]
|
||||
rfl
|
||||
rfl
|
||||
| States.position φ, States.inAsymp _ =>
|
||||
simp only [crPartF_position, crPartF_negAsymp]
|
||||
rw [𝓞.superCommuteF_create_create]
|
||||
rfl
|
||||
rfl
|
||||
| States.inAsymp _, States.inAsymp _ =>
|
||||
simp only [crPartF_negAsymp]
|
||||
rw [𝓞.superCommuteF_create_create]
|
||||
rfl
|
||||
rfl
|
||||
| States.inAsymp _, States.position _ =>
|
||||
simp only [crPartF_negAsymp, crPartF_position]
|
||||
rw [𝓞.superCommuteF_create_create]
|
||||
rfl
|
||||
rfl
|
||||
|
||||
lemma crAnF_superCommuteF_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, superCommuteF_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 (𝓞.superCommuteF_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_superCommuteF_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, superCommuteF_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_superCommuteF_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
|
||||
|
|
@ -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_normalOrderF_superCommuteF_eq_zero_mul`.
|
||||
|
||||
-/
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_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 [normalOrderF_superCommuteF_ofCrAnList_create_create_ofCrAnList φc φc' hφc hφc' φs φs']
|
||||
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommuteF_create_create φc φc' hφc hφc']
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_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 [normalOrderF_superCommuteF_ofCrAnList_annihilate_annihilate_ofCrAnList φa φa' hφa hφa' φs φs']
|
||||
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommuteF_annihilate_annihilate φa φa' hφa hφa']
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero
|
||||
(φa φa' : 𝓕.CrAnStates) (φs φs' : List 𝓕.CrAnStates) :
|
||||
𝓞.crAnF (normalOrderF
|
||||
(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 [normalOrderF_superCommuteF_ofCrAnList_create_create_ofCrAnList φa φa' hφa hφa' φs φs']
|
||||
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommuteF_create_create φa φa' hφa hφa']
|
||||
simp
|
||||
· rw [normalOrderF_superCommuteF_create_annihilate φa φa' hφa hφa' (ofCrAnList φs)
|
||||
(ofCrAnList φs')]
|
||||
simp
|
||||
· rw [normalOrderF_superCommuteF_annihilate_create φa' φa hφa' hφa (ofCrAnList φs)
|
||||
(ofCrAnList φs')]
|
||||
simp
|
||||
· rw [normalOrderF_superCommuteF_ofCrAnList_annihilate_annihilate_ofCrAnList φa φa' hφa hφa' φs φs']
|
||||
rw [map_smul, map_mul, map_mul, map_mul, 𝓞.superCommuteF_annihilate_annihilate φa φa' hφa hφa']
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnList_eq_zero
|
||||
(φa φa' : 𝓕.CrAnStates) (φs : List 𝓕.CrAnStates)
|
||||
(a : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrderF (ofCrAnList φs *
|
||||
[ofCrAnState φa, ofCrAnState φa']ₛca * a)) = 0 := by
|
||||
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ
|
||||
mulLinearMap ((ofCrAnList φs * [ofCrAnState φa, ofCrAnState φa']ₛca))) a = 0
|
||||
have hf : 𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ
|
||||
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_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero φa φa' φs l
|
||||
rw [hf]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnState_eq_zero_mul (φa φa' : 𝓕.CrAnStates)
|
||||
(a b : 𝓕.CrAnAlgebra) :
|
||||
𝓞.crAnF (normalOrderF (a * [ofCrAnState φa, ofCrAnState φa']ₛca * b)) = 0 := by
|
||||
rw [mul_assoc]
|
||||
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ mulLinearMap.flip
|
||||
([ofCrAnState φa, ofCrAnState φa']ₛca * b)) a = 0
|
||||
have hf : 𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ 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_normalOrderF_superCommuteF_ofCrAnList_eq_zero φa φa' _ _
|
||||
rw [hf]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnState_ofCrAnList_eq_zero_mul (φa : 𝓕.CrAnStates)
|
||||
(φs : List 𝓕.CrAnStates)
|
||||
(a b : 𝓕.CrAnAlgebra) :
|
||||
𝓞.crAnF (normalOrderF (a * [ofCrAnState φa, ofCrAnList φs]ₛca * b)) = 0 := by
|
||||
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 [crAnF_normalOrderF_superCommuteF_ofCrAnState_eq_zero_mul]
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnList_ofCrAnState_eq_zero_mul (φa : 𝓕.CrAnStates)
|
||||
(φs : List 𝓕.CrAnStates)
|
||||
(a b : 𝓕.CrAnAlgebra) :
|
||||
𝓞.crAnF (normalOrderF (a * [ofCrAnList φs, ofCrAnState φa]ₛca * b)) = 0 := by
|
||||
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 [crAnF_normalOrderF_superCommuteF_ofCrAnState_ofCrAnList_eq_zero_mul]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero_mul
|
||||
(φs φs' : List 𝓕.CrAnStates)
|
||||
(a b : 𝓕.CrAnAlgebra) :
|
||||
𝓞.crAnF (normalOrderF (a * [ofCrAnList φs, ofCrAnList φs']ₛca * b)) = 0 := by
|
||||
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 [crAnF_normalOrderF_superCommuteF_ofCrAnList_ofCrAnState_eq_zero_mul]
|
||||
|
||||
lemma crAnF_normalOrderF_superCommuteF_ofCrAnList_eq_zero_mul
|
||||
(φs : List 𝓕.CrAnStates)
|
||||
(a b c : 𝓕.CrAnAlgebra) :
|
||||
𝓞.crAnF (normalOrderF (a * [ofCrAnList φs, c]ₛca * b)) = 0 := by
|
||||
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ
|
||||
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF (ofCrAnList φs)) c = 0
|
||||
have hf : (𝓞.crAnF.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, ofListBasis_eq_ofList,
|
||||
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
|
||||
LinearMap.zero_apply]
|
||||
rw [crAnF_normalOrderF_superCommuteF_ofCrAnList_ofCrAnList_eq_zero_mul]
|
||||
rw [hf]
|
||||
simp
|
||||
|
||||
@[simp]
|
||||
lemma crAnF_normalOrderF_superCommuteF_eq_zero_mul
|
||||
(a b c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrderF (a * [d, c]ₛca * b)) = 0 := by
|
||||
change (𝓞.crAnF.toLinearMap ∘ₗ normalOrderF ∘ₗ
|
||||
mulLinearMap.flip b ∘ₗ mulLinearMap a ∘ₗ superCommuteF.flip c) d = 0
|
||||
have hf : (𝓞.crAnF.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, ofListBasis_eq_ofList,
|
||||
LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, AlgHom.toLinearMap_apply,
|
||||
LinearMap.zero_apply]
|
||||
rw [crAnF_normalOrderF_superCommuteF_ofCrAnList_eq_zero_mul]
|
||||
rw [hf]
|
||||
simp
|
||||
|
||||
@[simp]
|
||||
lemma crAnF_normalOrderF_superCommuteF_eq_zero_mul_right
|
||||
(b c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrderF ([d, c]ₛca * b)) = 0 := by
|
||||
rw [← crAnF_normalOrderF_superCommuteF_eq_zero_mul 1 b c d]
|
||||
simp
|
||||
|
||||
@[simp]
|
||||
lemma crAnF_normalOrderF_superCommuteF_eq_zero_mul_left
|
||||
(a c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrderF (a * [d, c]ₛca)) = 0 := by
|
||||
rw [← crAnF_normalOrderF_superCommuteF_eq_zero_mul a 1 c d]
|
||||
simp
|
||||
|
||||
@[simp]
|
||||
lemma crAnF_normalOrderF_superCommuteF_eq_zero
|
||||
(c d : 𝓕.CrAnAlgebra) : 𝓞.crAnF (normalOrderF [d, c]ₛca) = 0 := by
|
||||
rw [← crAnF_normalOrderF_superCommuteF_eq_zero_mul 1 1 c d]
|
||||
simp
|
||||
|
||||
/-!
|
||||
|
||||
## Swapping terms in a normal order.
|
||||
|
||||
-/
|
||||
|
||||
lemma crAnF_normalOrderF_ofState_ofState_swap (φ φ' : 𝓕.States) :
|
||||
𝓞.crAnF (normalOrderF (ofState φ * ofState φ')) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') • 𝓞.crAnF (normalOrderF (ofState φ' * ofState φ)) := by
|
||||
rw [← ofStateList_singleton, ← ofStateList_singleton,
|
||||
ofStateList_mul_ofStateList_eq_superCommuteF]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_ofCrAnState_ofCrAnList_swap (φ : 𝓕.CrAnStates)
|
||||
(φs : List 𝓕.CrAnStates) :
|
||||
𝓞.crAnF (normalOrderF (ofCrAnState φ * ofCrAnList φs)) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs) • 𝓞.crAnF (normalOrderF (ofCrAnList φs * ofCrAnState φ)) := by
|
||||
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofCrAnList_eq_superCommuteF]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_ofCrAnState_ofStatesList_swap (φ : 𝓕.CrAnStates)
|
||||
(φ' : List 𝓕.States) :
|
||||
𝓞.crAnF (normalOrderF (ofCrAnState φ * ofStateList φ')) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
|
||||
𝓞.crAnF (normalOrderF (ofStateList φ' * ofCrAnState φ)) := by
|
||||
rw [← ofCrAnList_singleton, ofCrAnList_mul_ofStateList_eq_superCommuteF]
|
||||
simp
|
||||
|
||||
lemma crAnF_normalOrderF_anPartF_ofStatesList_swap (φ : 𝓕.States)
|
||||
(φ' : List 𝓕.States) :
|
||||
𝓞.crAnF (normalOrderF (anPartF φ * ofStateList φ')) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
|
||||
𝓞.crAnF (normalOrderF (ofStateList φ' * anPartF φ)) := by
|
||||
match φ with
|
||||
| .inAsymp φ =>
|
||||
simp
|
||||
| .position φ =>
|
||||
simp only [anPartF_position, instCommGroup.eq_1]
|
||||
rw [crAnF_normalOrderF_ofCrAnState_ofStatesList_swap]
|
||||
rfl
|
||||
| .outAsymp φ =>
|
||||
simp only [anPartF_posAsymp, instCommGroup.eq_1]
|
||||
rw [crAnF_normalOrderF_ofCrAnState_ofStatesList_swap]
|
||||
rfl
|
||||
|
||||
lemma crAnF_normalOrderF_ofStatesList_anPartF_swap (φ : 𝓕.States) (φ' : List 𝓕.States) :
|
||||
𝓞.crAnF (normalOrderF (ofStateList φ' * anPartF φ))
|
||||
= 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
|
||||
𝓞.crAnF (normalOrderF (anPartF φ * ofStateList φ')) := by
|
||||
rw [crAnF_normalOrderF_anPartF_ofStatesList_swap]
|
||||
simp [smul_smul, FieldStatistic.exchangeSign_mul_self]
|
||||
|
||||
lemma crAnF_normalOrderF_ofStatesList_mul_anPartF_swap (φ : 𝓕.States)
|
||||
(φ' : List 𝓕.States) :
|
||||
𝓞.crAnF (normalOrderF (ofStateList φ') * anPartF φ) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φ') •
|
||||
𝓞.crAnF (normalOrderF (anPartF φ * ofStateList φ')) := by
|
||||
rw [← normalOrderF_mul_anPartF]
|
||||
rw [crAnF_normalOrderF_ofStatesList_anPartF_swap]
|
||||
|
||||
/-!
|
||||
|
||||
## Super commutators with a normal ordered term as sums
|
||||
|
||||
-/
|
||||
lemma crAnF_ofCrAnState_superCommuteF_normalOrderF_ofCrAnList_eq_sum (φ : 𝓕.CrAnStates)
|
||||
(φs : List 𝓕.CrAnStates) : 𝓞.crAnF ([ofCrAnState φ, normalOrderF (ofCrAnList φs)]ₛca) =
|
||||
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
|
||||
𝓞.crAnF ([ofCrAnState φ, ofCrAnState φs[n]]ₛca)
|
||||
* 𝓞.crAnF (normalOrderF (ofCrAnList (φs.eraseIdx n))) := by
|
||||
rw [normalOrderF_ofCrAnList, map_smul, map_smul]
|
||||
rw [crAnF_superCommuteF_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_normalOrderF, 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 [𝓞.superCommuteF_different_statistics _ _ hs]
|
||||
simp
|
||||
|
||||
lemma crAnF_ofCrAnState_superCommuteF_normalOrderF_ofStateList_eq_sum (φ : 𝓕.CrAnStates)
|
||||
(φs : List 𝓕.States) : 𝓞.crAnF ([ofCrAnState φ, normalOrderF (ofStateList φs)]ₛca) =
|
||||
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
|
||||
𝓞.crAnF ([ofCrAnState φ, ofState φs[n]]ₛca)
|
||||
* 𝓞.crAnF (normalOrderF (ofStateList (φs.eraseIdx n))) := by
|
||||
conv_lhs =>
|
||||
rw [ofStateList_sum, map_sum, map_sum, map_sum]
|
||||
enter [2, s]
|
||||
rw [crAnF_ofCrAnState_superCommuteF_normalOrderF_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
|
||||
`[anPartF φ, 𝓝ᶠ(φs)] = ∑ i, sᵢ • [anPartF φ, φᵢ]ₛca * 𝓝ᶠ(φ₀…φᵢ₋₁φᵢ₊₁…φₙ)`
|
||||
where `sᵢ` is the exchange sign for `φ` and `φ₀…φᵢ₋₁`.
|
||||
|
||||
The origin of this result is
|
||||
- `superCommuteF_ofCrAnList_ofCrAnList_eq_sum`
|
||||
-/
|
||||
lemma crAnF_anPartF_superCommuteF_normalOrderF_ofStateList_eq_sum (φ : 𝓕.States) (φs : List 𝓕.States) :
|
||||
𝓞.crAnF ([anPartF φ, 𝓝ᶠ(φs)]ₛca) =
|
||||
∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
|
||||
𝓞.crAnF ([anPartF φ, ofState φs[n]]ₛca) * 𝓞.crAnF 𝓝ᶠ(φs.eraseIdx n) := by
|
||||
match φ with
|
||||
| .inAsymp φ =>
|
||||
simp
|
||||
| .position φ =>
|
||||
simp only [anPartF_position, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
|
||||
rw [crAnF_ofCrAnState_superCommuteF_normalOrderF_ofStateList_eq_sum]
|
||||
simp [crAnStatistics]
|
||||
| .outAsymp φ =>
|
||||
simp only [anPartF_posAsymp, instCommGroup.eq_1, Fin.getElem_fin, Algebra.smul_mul_assoc]
|
||||
rw [crAnF_ofCrAnState_superCommuteF_normalOrderF_ofStateList_eq_sum]
|
||||
simp [crAnStatistics]
|
||||
|
||||
/-!
|
||||
|
||||
## Multiplying with normal ordered terms
|
||||
|
||||
-/
|
||||
/--
|
||||
Within a proto-operator algebra we have that
|
||||
`anPartF φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ((anPartF φ)φ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
|
||||
-/
|
||||
lemma crAnF_anPartF_mul_normalOrderF_ofStatesList_eq_superCommuteF (φ : 𝓕.States)
|
||||
(φ' : List 𝓕.States) :
|
||||
𝓞.crAnF (anPartF φ * normalOrderF (ofStateList φ')) =
|
||||
𝓞.crAnF (normalOrderF (anPartF φ * ofStateList φ')) +
|
||||
𝓞.crAnF ([anPartF φ, normalOrderF (ofStateList φ')]ₛca) := by
|
||||
rw [anPartF_mul_normalOrderF_ofStateList_eq_superCommuteF]
|
||||
simp only [instCommGroup.eq_1, map_add, map_smul]
|
||||
congr
|
||||
rw [crAnF_normalOrderF_anPartF_ofStatesList_swap]
|
||||
|
||||
/--
|
||||
Within a proto-operator algebra we have that
|
||||
`φ * 𝓝ᶠ(φ₀φ₁…φₙ) = 𝓝ᶠ(φφ₀φ₁…φₙ) + [anpart φ, 𝓝ᶠ(φ₀φ₁…φₙ)]ₛca`.
|
||||
-/
|
||||
lemma crAnF_ofState_mul_normalOrderF_ofStatesList_eq_superCommuteF (φ : 𝓕.States)
|
||||
(φs : List 𝓕.States) : 𝓞.crAnF (ofState φ * 𝓝ᶠ(φs)) =
|
||||
𝓞.crAnF (normalOrderF (ofState φ * ofStateList φs)) +
|
||||
𝓞.crAnF ([anPartF φ, 𝓝ᶠ(φs)]ₛca) := by
|
||||
conv_lhs => rw [ofState_eq_crPartF_add_anPartF]
|
||||
rw [add_mul, map_add, crAnF_anPartF_mul_normalOrderF_ofStatesList_eq_superCommuteF, ← add_assoc,
|
||||
← normalOrderF_crPartF_mul, ← map_add]
|
||||
conv_lhs =>
|
||||
lhs
|
||||
rw [← map_add, ← add_mul, ← ofState_eq_crPartF_add_anPartF]
|
||||
|
||||
/-- 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)) : 𝓞.A :=
|
||||
match n with
|
||||
| none => 1
|
||||
| some n => 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) •
|
||||
𝓞.crAnF ([anPartF φ, ofState φs[n]]ₛca)
|
||||
|
||||
/--
|
||||
Within a proto-operator algebra,
|
||||
`φ * N(φ₀φ₁…φₙ) = N(φφ₀φ₁…φₙ) + ∑ i, (sᵢ • [anPartF φ, φᵢ]ₛ) * N(φ₀φ₁…φᵢ₋₁φᵢ₊₁…φₙ)`,
|
||||
where `sₙ` is the exchange sign for `φ` and `φ₀φ₁…φᵢ₋₁`.
|
||||
-/
|
||||
lemma crAnF_ofState_mul_normalOrderF_ofStatesList_eq_sum (φ : 𝓕.States)
|
||||
(φs : List 𝓕.States) :
|
||||
𝓞.crAnF (ofState φ * normalOrderF (ofStateList φs)) =
|
||||
∑ n : Option (Fin φs.length),
|
||||
contractStateAtIndex φ φs n *
|
||||
𝓞.crAnF (normalOrderF (ofStateList (HepLean.List.optionEraseZ φs φ n))) := by
|
||||
rw [crAnF_ofState_mul_normalOrderF_ofStatesList_eq_superCommuteF]
|
||||
rw [crAnF_anPartF_superCommuteF_normalOrderF_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_normalOrderF_insert (φ : 𝓕.States) (φs : List 𝓕.States)
|
||||
(k : Fin φs.length.succ) :
|
||||
𝓞.crAnF (normalOrderF (ofStateList (φ :: φs))) =
|
||||
𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs.take k) • 𝓞.crAnF (normalOrderF (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_superCommuteF, add_mul]
|
||||
simp only [instCommGroup.eq_1, Nat.succ_eq_add_one, ofList_singleton, Algebra.smul_mul_assoc,
|
||||
map_add, map_smul, crAnF_normalOrderF_superCommuteF_eq_zero_mul_right, add_zero, smul_smul,
|
||||
exchangeSign_mul_self_swap, one_smul]
|
||||
rw [← ofStateList_append, ← ofStateList_append]
|
||||
simp
|
||||
|
||||
end ProtoOperatorAlgebra
|
||||
|
||||
end FieldSpecification
|
||||
|
|
@ -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 ([anPartF φ, ofState ψ]ₛca) := by
|
||||
conv_rhs =>
|
||||
rw [ofState_eq_crPartF_add_anPartF]
|
||||
rw [map_add, map_add, crAnF_superCommuteF_anPartF_anPartF, superCommuteF_anPartF_crPartF]
|
||||
simp only [timeContract, instCommGroup.eq_1, Algebra.smul_mul_assoc, add_zero]
|
||||
rw [timeOrderF_ofState_ofState_ordered h]
|
||||
rw [normalOrderF_ofState_mul_ofState]
|
||||
simp only [instCommGroup.eq_1]
|
||||
rw [ofState_eq_crPartF_add_anPartF, ofState_eq_crPartF_add_anPartF]
|
||||
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_normalOrderF_ofState_ofState_swap]
|
||||
rw [timeOrderF_ofState_ofState_not_ordered_eq_timeOrderF 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_superCommuteF_anPartF_ofState_mem_center _ _
|
||||
· rw [timeContract_of_not_timeOrderRel _ _ _ h]
|
||||
refine Subalgebra.smul_mem (Subalgebra.center ℂ 𝓞.A) ?_ 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ)
|
||||
rw [timeContract_of_timeOrderRel]
|
||||
exact 𝓞.crAnF_superCommuteF_anPartF_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_superCommuteF_anPartF_ofState_diff_grade_zero]
|
||||
exact h
|
||||
· rw [timeContract_of_not_timeOrderRel _ _ _ h1]
|
||||
rw [timeContract_of_timeOrderRel _ _ _]
|
||||
rw [crAnF_superCommuteF_anPartF_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,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,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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
/-!
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
/-!
|
||||
|
||||
|
|
|
|||
|
|
@ -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,13 @@ 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 +72,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.superCommuteF
|
||||
(CrAnAlgebra.anPartF φ)) (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 +105,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 +156,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 +167,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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -35,15 +35,15 @@ Let `c` be a Wick Contraction for `φs := φ₀φ₁…φₙ`.
|
|||
We have (roughly) `𝓝ᶠ([φsΛ ↩Λ φ i none]ᵘᶜ) = s • 𝓝ᶠ(φ :: [φsΛ]ᵘᶜ)`
|
||||
Where `s` is the exchange sign for `φ` and the uncontracted fields in `φ₀φ₁…φᵢ₋₁`.
|
||||
-/
|
||||
lemma normalOrderF_uncontracted_none (φ : 𝓕.States) (φs : List 𝓕.States)
|
||||
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_normalOrderF_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]
|
||||
|
|
@ -105,10 +105,10 @@ We have (roughly) `N(c ↩Λ φ i k).uncontractedList`
|
|||
is equal to `N((c.uncontractedList).eraseIdx k')`
|
||||
where `k'` is the position in `c.uncontractedList` corresponding to `k`.
|
||||
-/
|
||||
lemma normalOrderF_uncontracted_some (φ : 𝓕.States) (φs : List 𝓕.States)
|
||||
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]
|
||||
|
|
@ -152,12 +152,12 @@ 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 [normalOrderF_uncontracted_none, sign_insert_none]
|
||||
· rw [normalOrder_uncontracted_none, sign_insert_none]
|
||||
simp only [Nat.succ_eq_add_one, timeContract_insertAndContract_none, instCommGroup.eq_1,
|
||||
Algebra.mul_smul_comm, Algebra.smul_mul_assoc, smul_smul]
|
||||
congr 1
|
||||
|
|
@ -202,18 +202,18 @@ 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]
|
||||
swap
|
||||
· exact hn _ hk
|
||||
rw [normalOrderF_uncontracted_some, sign_insert_some]
|
||||
rw [normalOrder_uncontracted_some, sign_insert_some]
|
||||
simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc]
|
||||
congr 1
|
||||
rw [mul_assoc, mul_comm (sign φs φsΛ), ← mul_assoc]
|
||||
|
|
@ -224,7 +224,7 @@ lemma wick_term_some_eq_wick_term_optionEraseZ (φ : 𝓕.States) (φs : List
|
|||
rw [WickContraction.timeConract_insertAndContract_some_eq_mul_contractStateAtIndex_lt]
|
||||
swap
|
||||
· exact hlt _
|
||||
rw [normalOrderF_uncontracted_some]
|
||||
rw [normalOrder_uncontracted_some]
|
||||
rw [sign_insert_some]
|
||||
simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc]
|
||||
congr 1
|
||||
|
|
@ -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_superCommuteF_anPartF_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_superCommuteF_anPartF_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))
|
||||
|
|
@ -277,11 +277,11 @@ The proof of this result primarily depends on
|
|||
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_normalOrderF_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,26 @@ 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 [timeOrderF_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, normalOrderF_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 +356,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 [timeOrderF_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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue