The type FieldStatistic is the type containing two elements bosonic and fermionic.
This type is used to specify if a field or operator obeys bosonic or fermionic statistics.
Constructors
bosonic : FieldStatistic
fermionic : FieldStatistic
By Joseph Tooby-Smith
Wicks theorem
In this note we walk through the important parts of the proof of the three versions of Wick's theorem for field operators containing carrying both fermionic and bosonic statistics, as it appears in PhysLean. Not every lemma or definition is covered here. The aim is to give just enough that the story can be understood.
Before proceeding with the steps in the proof, we review some basic terminology
related to Lean and type theory. The most important notion is that of a type.
We don't give any formal definition here, except to say that a type T, like a set, has
elements x which we say are of type T and write x : T. Examples of types include,
the type of natural numbers ℕ, the type of real numbers ℝ, the type of numbers
0, …, n-1 denoted Fin n. Given two types T and S, we can form the product type T × S,
and the function type T → S.
Types form the foundation of Lean and the theory behind them will be used both explicitly and implicitly throughout this note.
FieldStatistic : TypeFieldStatistic : Type
The type FieldStatistic is the type containing two elements bosonic and fermionic.
This type is used to specify if a field or operator obeys bosonic or fermionic statistics.
bosonic : FieldStatistic
fermionic : FieldStatistic
FieldStatistic.instCommGroup : CommGroup FieldStatisticFieldStatistic.instCommGroup : CommGroup FieldStatistic
The type FieldStatistic carries an instance of a commutative group in which
bosonic * bosonic = bosonic
bosonic * fermionic = fermionic
fermionic * bosonic = fermionic
fermionic * fermionic = bosonic
This group is isomorphic to ℤ₂.
The exchange sign, exchangeSign, is defined as the group homomorphism
FieldStatistic →* FieldStatistic →* ℂ,
for which exchangeSign a b is -1 if both a and b are fermionic and 1 otherwise.
The exchange sign is the sign one picks up on exchanging an operator or field φ₁ of statistic
a with an operator or field φ₂ of statistic b, i.e. φ₁φ₂ → φ₂φ₁.
The notation 𝓢(a, b) is used for the exchange sign of a and b.
FieldSpecification : Type 1FieldSpecification : Type 1
The structure FieldSpecification is defined to have the following content:
A type Field whose elements are the constituent fields of the theory.
For every field f in Field, a type PositionLabel f whose elements label the different
position operators associated with the field f. For example,
For f a real-scalar field, PositionLabel f will have a unique element.
For f a complex-scalar field, PositionLabel f will have two elements, one for the field
operator and one for its conjugate.
For f a Dirac fermion, PositionLabel f will have eight elements, one for each Lorentz
index of the field and its conjugate.
For f a Weyl fermion, PositionLabel f will have four elements, one for each Lorentz
index of the field and its conjugate.
For every field f in Field, a type AsymptoticLabel f whose elements label the different
types of incoming asymptotic field operators associated with the
field f (this also matches the types of outgoing asymptotic field operators).
For example,
For f a real-scalar field, AsymptoticLabel f will have a unique element.
For f a complex-scalar field, AsymptoticLabel f will have two elements, one for the
field operator and one for its conjugate.
For f a Dirac fermion, AsymptoticLabel f will have four elements, two for each spin.
For f a Weyl fermion, AsymptoticLabel f will have two elements, one for each spin.
For each field f in Field, a field statistic statistic f which classifies f as either
bosonic or fermionic.
FieldSpecification.mk
Field : Type
A type whose elements are the constituent fields of the theory.
PositionLabel : self.Field → Type
For every field f in Field, the type PositionLabel f has elements that label the
different position operators associated with the field f.
AsymptoticLabel : self.Field → Type
For every field f in Field, the type AsymptoticLabel f has elements that label
the different asymptotic based field operators associated with the field f.
statistic : self.Field → FieldStatistic
For every field f in Field, the field statistic statistic f classifies f as either
bosonic or fermionic.
For a field specification 𝓕, the inductive type 𝓕.FieldOp is defined
to contain the following elements:
For every f in 𝓕.Field, element of e of AsymptoticLabel f and 3-momentum p, an
element labelled inAsymp f e p corresponding to an incoming asymptotic field operator
of the field f, of label e (e.g. specifying the spin), and momentum p.
For every f in 𝓕.Field, element of e of PositionLabel f and space-time position x, an
element labelled position f e x corresponding to a position field operator of the field f,
of label e (e.g. specifying the Lorentz index), and position x.
For every f in 𝓕.Field, element of e of AsymptoticLabel f and 3-momentum p, an
element labelled outAsymp f e p corresponding to an outgoing asymptotic field operator of the
field f, of label e (e.g. specifying the spin), and momentum p.
As an example, if f corresponds to a Weyl-fermion field, then
For inAsymp f e p, e would correspond to a spin s, and inAsymp f e p would, once
represented in the operator algebra,
be proportional to the creation operator a(p, s).
position f e x, e would correspond to a Lorentz index a, and position f e x would,
once represented in the operator algebra, be proportional to the operator
∑ s, ∫ d³p/(…) (xₐ(p,s) a(p, s) e ^ (-i p x) + yₐ(p,s) a†(p, s) e ^ (-i p x)).
outAsymp f e p, e would correspond to a spin s, and outAsymp f e p would,
once represented in the operator algebra, be proportional to the
annihilation operator a†(p, s).
inAsymp {𝓕 : FieldSpecification} :
((f : 𝓕.Field) × 𝓕.AsymptoticLabel f) × Momentum →
𝓕.FieldOp
position {𝓕 : FieldSpecification} :
((f : 𝓕.Field) × 𝓕.PositionLabel f) × SpaceTime →
𝓕.FieldOp
outAsymp {𝓕 : FieldSpecification} :
((f : 𝓕.Field) × 𝓕.AsymptoticLabel f) × Momentum →
𝓕.FieldOp
For a field specification 𝓕, and an element φ of 𝓕.FieldOp.
The field statistic fieldOpStatistic φ is defined to be the statistic associated with
the field underlying φ.
The following notation is used in relation to fieldOpStatistic:
CreateAnnihilate : TypeCreateAnnihilate : Type
The type CreateAnnihilate is the type containing two elements create and annihilate.
This type is used to specify if an operator is a creation, or annihilation, operator
or the sum thereof or integral thereof etc.
create : CreateAnnihilate
annihilate : CreateAnnihilate
For a field specification 𝓕, the (sigma) type 𝓕.CrAnFieldOp
corresponds to the type of creation and annihilation parts of field operators.
It formally defined to consist of the following elements:
For each incoming asymptotic field operator φ in 𝓕.FieldOp an element
written as ⟨φ, ()⟩ in 𝓕.CrAnFieldOp, corresponding to the creation part of φ.
Here φ has no annihilation part. (Here () is the unique element of Unit.)
For each position field operator φ in 𝓕.FieldOp an element of 𝓕.CrAnFieldOp
written as ⟨φ, .create⟩, corresponding to the creation part of φ.
For each position field operator φ in 𝓕.FieldOp an element of 𝓕.CrAnFieldOp
written as ⟨φ, .annihilate⟩, corresponding to the annihilation part of φ.
For each outgoing asymptotic field operator φ in 𝓕.FieldOp an element
written as ⟨φ, ()⟩ in 𝓕.CrAnFieldOp, corresponding to the annihilation part of φ.
Here φ has no creation part. (Here () is the unique element of Unit.)
As an example, if f corresponds to a Weyl-fermion field, it would contribute
the following elements to 𝓕.CrAnFieldOp
For each spin s, an element corresponding to an incoming asymptotic operator: a(p, s).
For each each Lorentz
index a, an element corresponding to the creation part of a position operator:
∑ s, ∫ d³p/(…) (xₐ (p,s) a(p, s) e ^ (-i p x)).
For each each Lorentz
index a,an element corresponding to annihilation part of a position operator:
∑ s, ∫ d³p/(…) (yₐ(p,s) a†(p, s) e ^ (-i p x)).
For each spin s, element corresponding to an outgoing asymptotic operator: a†(p, s).
FieldSpecification.crAnFieldOpToCreateAnnihilate (𝓕 : FieldSpecification) : 𝓕.CrAnFieldOp → CreateAnnihilateFieldSpecification.crAnFieldOpToCreateAnnihilate (𝓕 : FieldSpecification) : 𝓕.CrAnFieldOp → CreateAnnihilate
For a field specification 𝓕, 𝓕.crAnFieldOpToCreateAnnihilate is the map from
𝓕.CrAnFieldOp to CreateAnnihilate taking φ to create if
φ corresponds to an incoming asymptotic field operator or the creation part of a position based
field operator.
otherwise it takes φ to annihilate.
For a field specification 𝓕, and an element φ in 𝓕.CrAnFieldOp, the field
statistic crAnStatistics φ is defined to be the statistic associated with the field 𝓕.Field
(or the 𝓕.FieldOp) underlying φ.
The following notation is used in relation to crAnStatistics:
For φ an element of 𝓕.CrAnFieldOp, 𝓕 |>s φ is crAnStatistics φ.
For φs a list of 𝓕.CrAnFieldOp, 𝓕 |>s φs is the product of crAnStatistics φ over
the list φs.
Insert FieldSpecification.notation_remark here
For a field specification 𝓕, the algebra 𝓕.FieldOpFreeAlgebra is
the free algebra generated by 𝓕.CrAnFieldOp.
Insert FieldSpecification.FieldOpFreeAlgebra.naming_convention here
FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) : 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) : 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, and a element φ of 𝓕.CrAnFieldOp,
ofCrAnOpF φ is defined as the element of 𝓕.FieldOpFreeAlgebra formed by φ.
FieldSpecification.FieldOpFreeAlgebra.universality {𝓕 : FieldSpecification} {A : Type} [Semiring A] [Algebra ℂ A] (f : 𝓕.CrAnFieldOp → A) : ∃! g, ⇑g ∘ FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF = fFieldSpecification.FieldOpFreeAlgebra.universality {𝓕 : FieldSpecification} {A : Type} [Semiring A] [Algebra ℂ A] (f : 𝓕.CrAnFieldOp → A) : ∃! g, ⇑g ∘ FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF = f
The algebra 𝓕.FieldOpFreeAlgebra satisfies the universal property that for any other algebra
A (e.g. the operator algebra of the theory) with a map f : 𝓕.CrAnFieldOp → A (e.g.
the inclusion of the creation and annihilation parts of field operators into the
operator algebra) there is a unique algebra map g : 𝓕.FieldOpFreeAlgebra → A
such that g ∘ ofCrAnOpF = f.
The unique g is given by FreeAlgebra.lift ℂ f.
FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.ofCrAnListF {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, and a list φs of 𝓕.CrAnFieldOp,
ofCrAnListF φs is defined as the element of 𝓕.FieldOpFreeAlgebra
obtained by the product of ofCrAnListF φ for each φ in φs.
For example ofCrAnListF [φ₁, φ₂, φ₃] = ofCrAnOpF φ₁ * ofCrAnOpF φ₂ * ofCrAnOpF φ₃.
The set of all ofCrAnListF φs forms a basis of FieldOpFreeAlgebra 𝓕.
FieldSpecification.FieldOpFreeAlgebra.ofFieldOpF {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) : 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.ofFieldOpF {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) : 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, and an element φ of 𝓕.FieldOp,
ofFieldOpF φ is the element of 𝓕.FieldOpFreeAlgebra formed by summing over
ofCrAnOpF of the
creation and annihilation parts of φ.
For example, for φ an incoming asymptotic field operator we get
ofCrAnOpF ⟨φ, ()⟩, and for φ a
position field operator we get ofCrAnOpF ⟨φ, .create⟩ + ofCrAnOpF ⟨φ, .annihilate⟩.
FieldSpecification.FieldOpFreeAlgebra.ofFieldOpListF {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.ofFieldOpListF {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, and a list φs of 𝓕.FieldOp,
𝓕.ofFieldOpListF φs is defined as the element of 𝓕.FieldOpFreeAlgebra
obtained by the product of ofFieldOpF φ for each φ in φs.
For example ofFieldOpListF [φ₁, φ₂, φ₃] = ofFieldOpF φ₁ * ofFieldOpF φ₂ * ofFieldOpF φ₃.
Insert FieldSpecification.FieldOpFreeAlgebra.notation_drop here
FieldSpecification.FieldOpFreeAlgebra.fieldOpFreeAlgebraGrade {𝓕 : FieldSpecification} : GradedAlgebra FieldSpecification.FieldOpFreeAlgebra.statisticSubmoduleFieldSpecification.FieldOpFreeAlgebra.fieldOpFreeAlgebraGrade {𝓕 : FieldSpecification} : GradedAlgebra FieldSpecification.FieldOpFreeAlgebra.statisticSubmodule
For a field specification 𝓕, the algebra 𝓕.FieldOpFreeAlgebra is graded by FieldStatistic.
Those ofCrAnListF φs for which φs has an overall bosonic statistic
(i.e. 𝓕 |>s φs = bosonic) span bosonic
submodule, whilst those ofCrAnListF φs for which φs has an overall fermionic statistic
(i.e. 𝓕 |>s φs = fermionic) span
the fermionic submodule.
FieldSpecification.FieldOpFreeAlgebra.superCommuteF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.superCommuteF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, the super commutator superCommuteF is defined as the linear
map 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra
which on the lists φs and φs' of 𝓕.CrAnFieldOp gives
superCommuteF φs φs' = φs * φs' - 𝓢(φs, φs') • φs' * φs.
The notation [a, b]ₛF can be used for superCommuteF a b.
FieldSpecification.FieldOpFreeAlgebra.superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum {𝓕 : FieldSpecification} (φs φs' : List 𝓕.CrAnFieldOp) : (FieldSpecification.FieldOpFreeAlgebra.superCommuteF (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs)) (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs') = ∑ n, (FieldStatistic.exchangeSign (FieldStatistic.ofList 𝓕.crAnStatistics φs)) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑n) φs')) • FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF (List.take (↑n) φs') * (FieldSpecification.FieldOpFreeAlgebra.superCommuteF (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs)) (FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF (φs'.get n)) * FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF (List.drop (↑n + 1) φs')FieldSpecification.FieldOpFreeAlgebra.superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum {𝓕 : FieldSpecification} (φs φs' : List 𝓕.CrAnFieldOp) : (FieldSpecification.FieldOpFreeAlgebra.superCommuteF (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs)) (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs') = ∑ n, (FieldStatistic.exchangeSign (FieldStatistic.ofList 𝓕.crAnStatistics φs)) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑n) φs')) • FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF (List.take (↑n) φs') * (FieldSpecification.FieldOpFreeAlgebra.superCommuteF (FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF φs)) (FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF (φs'.get n)) * FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF (List.drop (↑n + 1) φs')
For a field specification 𝓕, and two lists φs = φ₀…φₙ and φs' of 𝓕.CrAnFieldOp
the following super commutation relation holds:
[φs', φ₀…φₙ]ₛF = ∑ i, 𝓢(φs', φ₀…φᵢ₋₁) • φ₀…φᵢ₋₁ * [φs', φᵢ]ₛF * φᵢ₊₁ … φₙ
The proof of this relation is via induction on the length of φs.
For a field specification 𝓕, the algebra 𝓕.WickAlgebra is defined as the quotient
of the free algebra 𝓕.FieldOpFreeAlgebra by the ideal generated by
[ofCrAnOpF φc, ofCrAnOpF φc']ₛF for φc and φc' field creation operators.
This corresponds to the condition that two creation operators always super-commute.
[ofCrAnOpF φa, ofCrAnOpF φa']ₛF for φa and φa' field annihilation operators.
This corresponds to the condition that two annihilation operators always super-commute.
[ofCrAnOpF φ, ofCrAnOpF φ']ₛF for φ and φ' operators with different statistics.
This corresponds to the condition that two operators with different statistics always
super-commute. In other words, fermions and bosons always super-commute.
[ofCrAnOpF φ1, [ofCrAnOpF φ2, ofCrAnOpF φ3]ₛF]ₛF. This corresponds to the condition,
when combined with the conditions above, that the super-commutator is in the center
of the algebra.
FieldSpecification.WickAlgebra.ι {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₐ[ℂ] 𝓕.WickAlgebraFieldSpecification.WickAlgebra.ι {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₐ[ℂ] 𝓕.WickAlgebra
For a field specification 𝓕, ι is defined as the projection
𝓕.FieldOpFreeAlgebra →ₐ[ℂ] 𝓕.WickAlgebra
taking each element of 𝓕.FieldOpFreeAlgebra to its equivalence class in WickAlgebra 𝓕.
FieldSpecification.WickAlgebra.ofCrAnOp {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) : 𝓕.WickAlgebraFieldSpecification.WickAlgebra.ofCrAnOp {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) : 𝓕.WickAlgebra
For a field specification 𝓕 and an element φ of 𝓕.CrAnFieldOp,
ofCrAnOp φ is defined as the element of
𝓕.WickAlgebra given by ι (ofCrAnOpF φ).
FieldSpecification.WickAlgebra.ofCrAnList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : 𝓕.WickAlgebraFieldSpecification.WickAlgebra.ofCrAnList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : 𝓕.WickAlgebra
For a field specification 𝓕 and a list φs of 𝓕.CrAnFieldOp,
ofCrAnList φs is defined as the element of
𝓕.WickAlgebra given by ι (ofCrAnListF φ).
For a field specification 𝓕 and an element φ of 𝓕.FieldOp,
ofFieldOp φ is defined as the element of
𝓕.WickAlgebra given by ι (ofFieldOpF φ).
FieldSpecification.WickAlgebra.ofFieldOpList {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : 𝓕.WickAlgebraFieldSpecification.WickAlgebra.ofFieldOpList {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : 𝓕.WickAlgebra
For a field specification 𝓕 and a list φs of 𝓕.FieldOp,
ofFieldOpList φs is defined as the element of
𝓕.WickAlgebra given by ι (ofFieldOpListF φ).
For a field specification 𝓕, and an element φ of 𝓕.FieldOp, the
annihilation part of 𝓕.FieldOp as an element of 𝓕.WickAlgebra.
Thus for φ
an incoming asymptotic state this is 0.
a position based state this is ofCrAnOp ⟨φ, .create⟩.
an outgoing asymptotic state this is ofCrAnOp ⟨φ, ()⟩.
For a field specification 𝓕, and an element φ of 𝓕.FieldOp, the
creation part of 𝓕.FieldOp as an element of 𝓕.WickAlgebra.
Thus for φ
an incoming asymptotic state this is ofCrAnOp ⟨φ, ()⟩.
a position based state this is ofCrAnOp ⟨φ, .create⟩.
an outgoing asymptotic state this is 0.
FieldSpecification.WickAlgebra.ofFieldOp_eq_crPart_add_anPart {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOp φ = FieldSpecification.WickAlgebra.crPart φ + FieldSpecification.WickAlgebra.anPart φFieldSpecification.WickAlgebra.ofFieldOp_eq_crPart_add_anPart {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOp φ = FieldSpecification.WickAlgebra.crPart φ + FieldSpecification.WickAlgebra.anPart φ
For field specification 𝓕, and an element φ of 𝓕.FieldOp the following relation holds:
ofFieldOp φ = crPart φ + anPart φ
That is, every field operator splits into its creation part plus its annihilation part.
FieldSpecification.WickAlgebra.WickAlgebraGrade {𝓕 : FieldSpecification} : GradedAlgebra FieldSpecification.WickAlgebra.statSubmoduleFieldSpecification.WickAlgebra.WickAlgebraGrade {𝓕 : FieldSpecification} : GradedAlgebra FieldSpecification.WickAlgebra.statSubmodule
For a field statistic 𝓕, the algebra 𝓕.WickAlgebra is graded by FieldStatistic.
Those ofCrAnList φs for which φs has an overall bosonic statistic
(i.e. 𝓕 |>s φs = bosonic) span bosonic
submodule, whilst those ofCrAnList φs for which φs has an overall fermionic statistic
(i.e. 𝓕 |>s φs = fermionic) span the fermionic submodule.
FieldSpecification.WickAlgebra.superCommute {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebraFieldSpecification.WickAlgebra.superCommute {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebra
For a field specification 𝓕, superCommute is the linear map
WickAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕
defined as the descent of ι ∘ superCommuteF in both arguments.
In particular for φs and φs' lists of 𝓕.CrAnFieldOp in WickAlgebra 𝓕 the following
relation holds:
superCommute φs φs' = φs * φs' - 𝓢(φs, φs') • φs' * φs
The notation [a, b]ₛ is used for superCommute a b.
For a field specification 𝓕, 𝓕.crAnTimeOrderRel is a relation on
𝓕.CrAnFieldOp representing time ordering.
It is defined such that 𝓕.crAnTimeOrderRel φ₀ φ₁ is true if and only if one of the following
holds
φ₀ is an outgoing asymptotic operator
φ₁ is an incoming asymptotic field operator
φ₀ and φ₁ are both position field operators where
the SpaceTime point of φ₀ has a time greater than or equal to that of φ₁.
Thus, colloquially 𝓕.crAnTimeOrderRel φ₀ φ₁ if φ₀ has time greater than or equal to φ₁.
The use of greater than rather then less than is because on ordering lists of operators
it is needed that the operator with the greatest time is to the left.
FieldSpecification.crAnTimeOrderList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOpFieldSpecification.crAnTimeOrderList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp
For a field specification 𝓕, and a list φs of 𝓕.CrAnFieldOp,
𝓕.crAnTimeOrderList φs is the list φs time-ordered using the insertion sort algorithm.
For a field specification 𝓕, and a list φs of 𝓕.CrAnFieldOp,
𝓕.crAnTimeOrderSign φs is the sign corresponding to the number of ferimionic-fermionic
exchanges undertaken to time-order (i.e. order with respect to 𝓕.crAnTimeOrderRel) φs using
the insertion sort algorithm.
FieldSpecification.FieldOpFreeAlgebra.timeOrderF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.timeOrderF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, timeOrderF is the linear map
FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕
defined by its action on the basis ofCrAnListF φs, taking
ofCrAnListF φs to
crAnTimeOrderSign φs • ofCrAnListF (crAnTimeOrderList φs).
That is, timeOrderF time-orders the field operators and multiplies by the sign of the
time order.
The notation 𝓣ᶠ(a) is used for timeOrderF a
FieldSpecification.WickAlgebra.timeOrder {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebraFieldSpecification.WickAlgebra.timeOrder {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebra
For a field specification 𝓕, timeOrder is the linear map
WickAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕
defined as the descent of ι ∘ₗ timeOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕 from
FieldOpFreeAlgebra 𝓕 to WickAlgebra 𝓕.
This descent exists because ι ∘ₗ timeOrderF is well-defined on equivalence classes.
The notation 𝓣(a) is used for timeOrder a.
FieldSpecification.WickAlgebra.timeOrder_eq_maxTimeField_mul_finset {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φs)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic (FieldSpecification.maxTimeField φ φs))) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic (FieldSpecification.eraseMaxTimeField φ φs).get {x | (FieldSpecification.maxTimeFieldPosFin φ φs).succAbove x < FieldSpecification.maxTimeFieldPosFin φ φs}) • FieldSpecification.WickAlgebra.ofFieldOp (FieldSpecification.maxTimeField φ φs) * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList (FieldSpecification.eraseMaxTimeField φ φs))FieldSpecification.WickAlgebra.timeOrder_eq_maxTimeField_mul_finset {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φs)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic (FieldSpecification.maxTimeField φ φs))) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic (FieldSpecification.eraseMaxTimeField φ φs).get {x | (FieldSpecification.maxTimeFieldPosFin φ φs).succAbove x < FieldSpecification.maxTimeFieldPosFin φ φs}) • FieldSpecification.WickAlgebra.ofFieldOp (FieldSpecification.maxTimeField φ φs) * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList (FieldSpecification.eraseMaxTimeField φ φs))
For a field specification 𝓕, the time order operator acting on a
list of 𝓕.FieldOp, 𝓣(φ₀…φₙ), is equal to
𝓢(φᵢ,φ₀…φᵢ₋₁) • φᵢ * 𝓣(φ₀…φᵢ₋₁φᵢ₊₁φₙ) where φᵢ is the maximal time field
operator in φ₀…φₙ.
The proof of this result ultimately relies on basic properties of ordering and signs.
FieldSpecification.WickAlgebra.timeOrder_timeOrder_mid {𝓕 : FieldSpecification} (a b c : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.timeOrder (a * b * c) = FieldSpecification.WickAlgebra.timeOrder (a * FieldSpecification.WickAlgebra.timeOrder b * c)FieldSpecification.WickAlgebra.timeOrder_timeOrder_mid {𝓕 : FieldSpecification} (a b c : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.timeOrder (a * b * c) = FieldSpecification.WickAlgebra.timeOrder (a * FieldSpecification.WickAlgebra.timeOrder b * c)
For a field specification 𝓕, and a, b, c in 𝓕.WickAlgebra, then
𝓣(a * b * c) = 𝓣(a * 𝓣(b) * c).
For a field specification 𝓕, 𝓕.normalOrderRel is a relation on 𝓕.CrAnFieldOp
representing normal ordering. It is defined such that 𝓕.normalOrderRel φ₀ φ₁
is true if one of the following is true
φ₀ is a field creation operator
φ₁ is a field annihilation operator.
Thus, colloquially 𝓕.normalOrderRel φ₀ φ₁ says the creation operators are less than
annihilation operators.
FieldSpecification.normalOrderList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOpFieldSpecification.normalOrderList {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp
For a field specification 𝓕, and a list φs of 𝓕.CrAnFieldOp,
𝓕.normalOrderList φs is the list φs normal-ordered using the
insertion sort algorithm. It puts creation operators on the left and annihilation operators on
the right. For example:
𝓕.normalOrderList [φ1c, φ1a, φ2c, φ2a] = [φ1c, φ2c, φ1a, φ2a]
For a field specification 𝓕, and a list φs of 𝓕.CrAnFieldOp, 𝓕.normalOrderSign φs is the
sign corresponding to the number of fermionic-fermionic exchanges undertaken to normal-order
φs using the insertion sort algorithm.
FieldSpecification.normalOrderSign_eraseIdx {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) (i : Fin φs.length) : FieldSpecification.normalOrderSign (φs.eraseIdx ↑i) = FieldSpecification.normalOrderSign φs * (FieldStatistic.exchangeSign (𝓕.crAnStatistics (φs.get i))) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑i) φs)) * (FieldStatistic.exchangeSign (𝓕.crAnStatistics (φs.get i))) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑(FieldSpecification.normalOrderEquiv i)) (FieldSpecification.normalOrderList φs)))FieldSpecification.normalOrderSign_eraseIdx {𝓕 : FieldSpecification} (φs : List 𝓕.CrAnFieldOp) (i : Fin φs.length) : FieldSpecification.normalOrderSign (φs.eraseIdx ↑i) = FieldSpecification.normalOrderSign φs * (FieldStatistic.exchangeSign (𝓕.crAnStatistics (φs.get i))) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑i) φs)) * (FieldStatistic.exchangeSign (𝓕.crAnStatistics (φs.get i))) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑(FieldSpecification.normalOrderEquiv i)) (FieldSpecification.normalOrderList φs)))
For a field specification 𝓕, a list φs = φ₀…φₙ of 𝓕.CrAnFieldOp and an i < φs.length,
then
normalOrderSign (φ₀…φᵢ₋₁φᵢ₊₁…φₙ) is equal to the product of
normalOrderSign φ₀…φₙ,
𝓢(φᵢ, φ₀…φᵢ₋₁) i.e. the sign needed to remove φᵢ from φ₀…φₙ,
𝓢(φᵢ, _) where _ is the list of elements appearing before φᵢ after normal ordering,
i.e.
the sign needed to insert φᵢ back into the normal-ordered list at the correct place.
FieldSpecification.FieldOpFreeAlgebra.normalOrderF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebraFieldSpecification.FieldOpFreeAlgebra.normalOrderF {𝓕 : FieldSpecification} : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra
For a field specification 𝓕, normalOrderF is the linear map
FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕
defined by its action on the basis ofCrAnListF φs, taking ofCrAnListF φs to
normalOrderSign φs • ofCrAnListF (normalOrderList φs).
That is, normalOrderF normal-orders the field operators and multiplies by the sign of the
normal order.
The notation 𝓝ᶠ(a) is used for normalOrderF a for a an element of
FieldOpFreeAlgebra 𝓕.
FieldSpecification.WickAlgebra.normalOrder {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebraFieldSpecification.WickAlgebra.normalOrder {𝓕 : FieldSpecification} : 𝓕.WickAlgebra →ₗ[ℂ] 𝓕.WickAlgebra
For a field specification 𝓕, normalOrder is the linear map
WickAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕
defined as the descent of ι ∘ₗ normalOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] WickAlgebra 𝓕
from FieldOpFreeAlgebra 𝓕 to WickAlgebra 𝓕.
This descent exists because ι ∘ₗ normalOrderF is well-defined on equivalence classes.
The notation 𝓝(a) is used for normalOrder a for a an element of WickAlgebra 𝓕.
FieldSpecification.WickAlgebra.normalOrder_superCommute_eq_zero {𝓕 : FieldSpecification} (a b : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.normalOrder ((FieldSpecification.WickAlgebra.superCommute a) b) = 0FieldSpecification.WickAlgebra.normalOrder_superCommute_eq_zero {𝓕 : FieldSpecification} (a b : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.normalOrder ((FieldSpecification.WickAlgebra.superCommute a) b) = 0
For a field specification 𝓕, and a and b in 𝓕.WickAlgebra the normal ordering
of the super commutator of a and b vanishes, i.e. 𝓝([a,b]ₛ) = 0.
FieldSpecification.WickAlgebra.ofCrAnOp_superCommute_normalOrder_ofCrAnList_sum {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) (φs : List 𝓕.CrAnFieldOp) : (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.ofCrAnOp φ)) (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofCrAnList φs)) = ∑ n, (FieldStatistic.exchangeSign (𝓕.crAnStatistics φ)) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑n) φs)) • (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.ofCrAnOp φ)) (FieldSpecification.WickAlgebra.ofCrAnOp φs[n]) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofCrAnList (φs.eraseIdx ↑n))FieldSpecification.WickAlgebra.ofCrAnOp_superCommute_normalOrder_ofCrAnList_sum {𝓕 : FieldSpecification} (φ : 𝓕.CrAnFieldOp) (φs : List 𝓕.CrAnFieldOp) : (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.ofCrAnOp φ)) (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofCrAnList φs)) = ∑ n, (FieldStatistic.exchangeSign (𝓕.crAnStatistics φ)) (FieldStatistic.ofList 𝓕.crAnStatistics (List.take (↑n) φs)) • (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.ofCrAnOp φ)) (FieldSpecification.WickAlgebra.ofCrAnOp φs[n]) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofCrAnList (φs.eraseIdx ↑n))
For a field specification 𝓕, an element φ of 𝓕.CrAnFieldOp, a list φs of 𝓕.CrAnFieldOp,
the following relation holds
[φ, 𝓝(φ₀…φₙ)]ₛ = ∑ i, 𝓢(φ, φ₀…φᵢ₋₁) • [φ, φᵢ]ₛ * 𝓝(φ₀…φᵢ₋₁φᵢ₊₁…φₙ).
The proof of this result ultimately goes as follows
The definition of normalOrder is used to rewrite 𝓝(φ₀…φₙ) as a scalar multiple of
a ofCrAnList φsn where φsn is the normal ordering of φ₀…φₙ.
superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum is used to rewrite the super commutator of φ
(considered as a list with one element) with
ofCrAnList φsn as a sum of super commutators, one for each element of φsn.
The fact that super-commutators are in the center of 𝓕.WickAlgebra is used to rearrange
terms.
Properties of ordered lists, and normalOrderSign_eraseIdx are then used to complete the proof.
FieldSpecification.WickAlgebra.ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOp φ * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ n, FieldSpecification.WickAlgebra.contractStateAtIndex φ φs n * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φs φ n))FieldSpecification.WickAlgebra.ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOp φ * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ n, FieldSpecification.WickAlgebra.contractStateAtIndex φ φs n * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φs φ n))
For a field specification 𝓕, a φ in 𝓕.FieldOp and a list φs of 𝓕.FieldOp
then φ * 𝓝(φ₀φ₁…φₙ) is equal to
𝓝(φφ₀φ₁…φₙ) + ∑ i, (𝓢(φ,φ₀φ₁…φᵢ₋₁) • [anPart φ, φᵢ]ₛ) * 𝓝(φ₀…φᵢ₋₁φᵢ₊₁…φₙ).
The proof ultimately goes as follows:
ofFieldOp_eq_crPart_add_anPart is used to split φ into its creation and annihilation parts.
The following relation is then used
crPart φ * 𝓝(φ₀φ₁…φₙ) = 𝓝(crPart φ * φ₀φ₁…φₙ).
It used that anPart φ * 𝓝(φ₀φ₁…φₙ) is equal to
𝓢(φ, φ₀φ₁…φₙ) 𝓝(φ₀φ₁…φₙ) * anPart φ + [anPart φ, 𝓝(φ₀φ₁…φₙ)]
Then it is used that
𝓢(φ, φ₀φ₁…φₙ) 𝓝(φ₀φ₁…φₙ) * anPart φ = 𝓝(anPart φ * φ₀φ₁…φₙ)
The result ofCrAnOp_superCommute_normalOrder_ofCrAnList_sum is used
to expand [anPart φ, 𝓝(φ₀φ₁…φₙ)] as a sum.
WickContraction (n : ℕ) : TypeWickContraction (n : ℕ) : Type
Given a natural number n, which will correspond to the number of fields needing
contracting, a Wick contraction
is a finite set of pairs of Fin n (numbers 0, ..., n-1), such that no
element of Fin n occurs in more than one pair. The pairs are the positions of fields we
'contract' together.
For n = 3 there are 4 possible Wick contractions:
∅, corresponding to the case where no fields are contracted.
{{0, 1}}, corresponding to the case where the field at position 0 and 1 are contracted.
{{0, 2}}, corresponding to the case where the field at position 0 and 2 are contracted.
{{1, 2}}, corresponding to the case where the field at position 1 and 2 are contracted.
The proof of this result uses the fact that Lean is an executable programming language
and can calculate all Wick contractions for a given n.
WickContraction.mem_four (c : WickContraction 4) : ↑c ∈ {∅, {{0, 1}}, {{0, 2}}, {{0, 3}}, {{1, 2}}, {{1, 3}}, {{2, 3}}, {{0, 1}, {2, 3}}, {{0, 2}, {1, 3}}, {{0, 3}, {1, 2}}}WickContraction.mem_four (c : WickContraction 4) : ↑c ∈ {∅, {{0, 1}}, {{0, 2}}, {{0, 3}}, {{1, 2}}, {{1, 3}}, {{2, 3}}, {{0, 1}, {2, 3}}, {{0, 2}, {1, 3}}, {{0, 3}, {1, 2}}}
For n = 4 there are 10 possible Wick contractions including e.g.
∅, corresponding to the case where no fields are contracted.
{{0, 1}, {2, 3}}, corresponding to the case where the fields at position 0 and 1 are
contracted, and the fields at position 2 and 3 are contracted.
{{0, 2}, {1, 3}}, corresponding to the case where the fields at position 0 and 2 are
contracted, and the fields at position 1 and 3 are contracted.
The proof of this result uses the fact that Lean is an executable programming language
and can calculate all Wick contractions for a given n.
Insert WickContraction.contraction_notation here
WickContraction.GradingCompliant {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : PropWickContraction.GradingCompliant {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : Prop
For a field specification 𝓕, φs a list of 𝓕.FieldOp and a Wick contraction
φsΛ of φs, the Wick contraction φsΛ is said to be GradingCompliant if
for every pair in φsΛ the contracted fields are either both fermionic or both bosonic.
In other words, in a GradingCompliant Wick contraction if
no contracted pairs occur between fermionic and bosonic fields.
WickContraction.card_eq_cardFun (n : ℕ) : Fintype.card (WickContraction n) = WickContraction.cardFun nWickContraction.card_eq_cardFun (n : ℕ) : Fintype.card (WickContraction n) = WickContraction.cardFun n
The number of Wick contractions in WickContraction n is equal to the terms in
Online Encyclopedia of Integer Sequences (OEIS) A000085. That is:
1, 1, 2, 4, 10, 26, 76, 232, 764, 2620, 9496, ...
For a Wick contraction c, c.uncontracted is defined as the finset of elements of Fin n
which are not in any contracted pair.
WickContraction.uncontractedListGet {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : List 𝓕.FieldOpWickContraction.uncontractedListGet {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : List 𝓕.FieldOp
Given a Wick Contraction φsΛ of a list φs of 𝓕.FieldOp. The list
φsΛ.uncontractedListGet of 𝓕.FieldOp is defined as the list φs with
all contracted positions removed, leaving the uncontracted 𝓕.FieldOp.
The notation [φsΛ]ᵘᶜ is used for φsΛ.uncontractedListGet.
WickContraction.insertAndContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φ : 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : Option { x // x ∈ φsΛ.uncontracted }) : WickContraction (φs.insertIdx (↑i) φ).lengthWickContraction.insertAndContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φ : 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : Option { x // x ∈ φsΛ.uncontracted }) : WickContraction (φs.insertIdx (↑i) φ).length
Given a Wick contraction φsΛ for a list φs of 𝓕.FieldOp,
an element φ of 𝓕.FieldOp, an i ≤ φs.length and a k
in Option φsΛ.uncontracted i.e. is either none or
some element of φsΛ.uncontracted, the new Wick contraction
φsΛ.insertAndContract φ i k is defined by inserting φ into φs after
the first i-elements and moving the values representing the contracted pairs in φsΛ
accordingly.
If k is not none, but rather some k, to this contraction is added the contraction
of φ (at position i) with the new position of k after φ is added.
In other words, φsΛ.insertAndContract φ i k is formed by adding φ to φs at position i,
and contracting φ with the field originally at position k if k is not none.
It is a Wick contraction of the list φs.insertIdx φ i corresponding to φs with φ inserted at
position i.
The notation φsΛ ↩Λ φ i k is used to denote φsΛ.insertAndContract φ i k.
WickContraction.insertLift_sum.{u_1} {𝓕 : FieldSpecification} {M : Type u_1} (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp} (i : Fin φs.length.succ) [AddCommMonoid M] (f : WickContraction (φs.insertIdx (↑i) φ).length → M) : ∑ c, f c = ∑ φsΛ, ∑ k, f (WickContraction.insertAndContract φ φsΛ i k)WickContraction.insertLift_sum.{u_1} {𝓕 : FieldSpecification} {M : Type u_1} (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp} (i : Fin φs.length.succ) [AddCommMonoid M] (f : WickContraction (φs.insertIdx (↑i) φ).length → M) : ∑ c, f c = ∑ φsΛ, ∑ k, f (WickContraction.insertAndContract φ φsΛ i k)
For a list φs of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp and a i ≤ φs.length then a sum over
Wick contractions of φs with φ inserted at i is equal to the sum over Wick contractions
φsΛ of just φs and the sum over optional uncontracted elements of the φsΛ.
In other words,
∑ (φsΛ : WickContraction (φs.insertIdx i φ).length), f φsΛ
where (φs.insertIdx i φ) is φs with φ inserted at position i. is equal to
∑ (φsΛ : WickContraction φs.length), ∑ k, f (φsΛ ↩Λ φ i k) .
where the sum over k is over all k in Option φsΛ.uncontracted.
WickContraction.join {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) : WickContraction φs.lengthWickContraction.join {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) : WickContraction φs.length
Given a list φs of 𝓕.FieldOp, a Wick contraction φsΛ of φs and a Wick contraction
φsucΛ of [φsΛ]ᵘᶜ, join φsΛ φsucΛ is defined as the Wick contraction of φs consisting of
the contractions in φsΛ and those in φsucΛ.
As an example, for φs = [φ1, φ2, φ3, φ4],
φsΛ = {{0, 1}} corresponding to the contraction of φ1 and φ2 in φs and
φsucΛ = {{0, 1}}
corresponding to the contraction of φ3 and φ4 in [φsΛ]ᵘᶜ = [φ3, φ4], then
join φsΛ φsucΛ is the contraction {{0, 1}, {2, 3}} of φs.
WickContraction.sign {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : ℂWickContraction.sign {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : ℂ
For a list φs of 𝓕.FieldOp, and a Wick contraction φsΛ of φs,
the complex number φsΛ.sign is defined to be the sign (1 or -1) corresponding
to the number of fermionic-fermionic exchanges that must be done to put
contracted pairs within φsΛ next to one another, starting recursively
from the contracted pair
whose first element occurs at the left-most position.
As an example, if [φ1, φ2, φ3, φ4] correspond to fermionic fields then the sign
associated with
{{0, 1}} is 1
{{0, 1}, {2, 3}} is 1
{{0, 2}, {1, 3}} is -1
WickContraction.join_sign {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) (hc : WickContraction.GradingCompliant φs φsΛ) : WickContraction.sign φs (φsΛ.join φsucΛ) = WickContraction.sign φs φsΛ * WickContraction.sign φsΛ.uncontractedListGet φsucΛWickContraction.join_sign {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) (hc : WickContraction.GradingCompliant φs φsΛ) : WickContraction.sign φs (φsΛ.join φsucΛ) = WickContraction.sign φs φsΛ * WickContraction.sign φsΛ.uncontractedListGet φsucΛ
For a list φs of 𝓕.FieldOp, a grading compliant Wick contraction φsΛ of φs,
and a Wick contraction φsucΛ of [φsΛ]ᵘᶜ, the following relation holds
(join φsΛ φsucΛ).sign = φsΛ.sign * φsucΛ.sign.
In φsΛ.sign the sign is determined by starting with the contracted pair
whose first element occurs at the left-most position. This lemma manifests that this
choice does not matter, and that contracted pairs can be brought together in any order.
WickContraction.sign_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : WickContraction.GradingCompliant φs φsΛ) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i none) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | (φsΛ.getDual? x).isSome = true ∧ i.succAbove x < i}) * WickContraction.sign φs φsΛWickContraction.sign_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : WickContraction.GradingCompliant φs φsΛ) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i none) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | (φsΛ.getDual? x).isSome = true ∧ i.succAbove x < i}) * WickContraction.sign φs φsΛ
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a graded compliant Wick contraction φsΛ of φs,
an i ≤ φs.length, and a φ in 𝓕.FieldOp, then
(φsΛ ↩Λ φ i none).sign = s * φsΛ.sign
where s is the sign arrived at by moving φ through the elements of φ₀…φᵢ₋₁ which
are contracted with some element.
The proof of this result involves a careful consideration of the contributions of different
FieldOps in φs to the sign of φsΛ ↩Λ φ i none.
WickContraction.sign_insert_none_zero {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : WickContraction.sign (φs.insertIdx (↑0) φ) (WickContraction.insertAndContract φ φsΛ 0 none) = WickContraction.sign φs φsΛWickContraction.sign_insert_none_zero {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : WickContraction.sign (φs.insertIdx (↑0) φ) (WickContraction.insertAndContract φ φsΛ 0 none) = WickContraction.sign φs φsΛ
WickContraction.sign_insert_some_of_not_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (hk : ¬i.succAbove ↑k < i) (hg : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) * (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) * WickContraction.sign φs φsΛWickContraction.sign_insert_some_of_not_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (hk : ¬i.succAbove ↑k < i) (hg : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) * (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) * WickContraction.sign φs φsΛ
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted such that i ≤ k,
the sign of φsΛ ↩Λ φ i (some k) is equal to the product of
the sign associated with moving φ through the φsΛ-uncontracted FieldOp in φ₀…φₖ₋₁,
the sign associated with moving φ through all the FieldOp in φ₀…φᵢ₋₁,
the sign of φsΛ.
The proof of this result involves a careful consideration of the contributions of different
FieldOp in φs to the sign of φsΛ ↩Λ φ i (some k).
WickContraction.sign_insert_some_of_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (hk : i.succAbove ↑k < i) (hg : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x ≤ ↑k})) * (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) * WickContraction.sign φs φsΛWickContraction.sign_insert_some_of_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (hk : i.succAbove ↑k < i) (hg : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑i) φ) (WickContraction.insertAndContract φ φsΛ i (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x ≤ ↑k})) * (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) * WickContraction.sign φs φsΛ
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted such that k<i,
the sign of φsΛ ↩Λ φ i (some k) is equal to the product of
the sign associated with moving φ through the φsΛ-uncontracted FieldOp in φ₀…φₖ,
the sign associated with moving φ through all FieldOp in φ₀…φᵢ₋₁,
the sign of φsΛ.
The proof of this result involves a careful consideration of the contributions of different
FieldOp in φs to the sign of φsΛ ↩Λ φ i (some k).
WickContraction.sign_insert_some_zero {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) (hn : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑0) φ) (WickContraction.insertAndContract φ φsΛ 0 (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) * WickContraction.sign φs φsΛWickContraction.sign_insert_some_zero {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) (hn : WickContraction.GradingCompliant φs φsΛ ∧ 𝓕.fieldOpStatistic φ = 𝓕.fieldOpStatistic φs[↑k]) : WickContraction.sign (φs.insertIdx (↑0) φ) (WickContraction.insertAndContract φ φsΛ 0 (some k)) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) * WickContraction.sign φs φsΛ
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, and a k in φsΛ.uncontracted,
the sign of φsΛ ↩Λ φ 0 (some k) is equal to the product of
the sign associated with moving φ through the φsΛ-uncontracted FieldOp in φ₀…φₖ₋₁,
the sign of φsΛ.
This is a direct corollary of sign_insert_some_of_not_lt.
FieldSpecification.WickAlgebra.normalOrder_uncontracted_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (WickContraction.insertAndContract φ φsΛ i none).uncontractedListGet) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | i.succAbove x < i})) • FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet))FieldSpecification.WickAlgebra.normalOrder_uncontracted_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (WickContraction.insertAndContract φ φsΛ i none).uncontractedListGet) = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | i.succAbove x < i})) • FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, and a i ≤ φs.length, then the following relation holds:
𝓝([φsΛ ↩Λ φ i none]ᵘᶜ) = s • 𝓝(φ :: [φsΛ]ᵘᶜ)
where s is the exchange sign for φ and the uncontracted fields in φ₀…φᵢ₋₁.
The proof of this result ultimately is a consequence of normalOrder_superCommute_eq_zero.
FieldSpecification.WickAlgebra.normalOrder_uncontracted_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) : FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (WickContraction.insertAndContract φ φsΛ i (some k)).uncontractedListGet) = FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k))))FieldSpecification.WickAlgebra.normalOrder_uncontracted_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) : FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (WickContraction.insertAndContract φ φsΛ i (some k)).uncontractedListGet) = FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k))))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted, then
𝓝([φsΛ ↩Λ φ i (some k)]ᵘᶜ) is equal to the normal ordering of [φsΛ]ᵘᶜ with the 𝓕.FieldOp
corresponding to k removed.
The proof of this result ultimately is a consequence of definitions.
WickContraction.staticContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : ↥(Subalgebra.center ℂ 𝓕.WickAlgebra)WickContraction.staticContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : ↥(Subalgebra.center ℂ 𝓕.WickAlgebra)
For a list φs of 𝓕.FieldOp and a Wick contraction φsΛ, the
element of the center of 𝓕.WickAlgebra, φsΛ.staticContract is defined as the product
of [anPart φs[j], φs[k]]ₛ over contracted pairs {j, k} in φsΛ
with j < k.
WickContraction.staticContract_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (WickContraction.insertAndContract φ φsΛ i none).staticContract = φsΛ.staticContractWickContraction.staticContract_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (WickContraction.insertAndContract φ φsΛ i none).staticContract = φsΛ.staticContract
WickContraction.staticContract_insert_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : { x // x ∈ φsΛ.uncontracted }) : (WickContraction.insertAndContract φ φsΛ i (some j)).staticContract = (if i < i.succAbove ↑j then ⟨(FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φ)) (FieldSpecification.WickAlgebra.ofFieldOp φs[↑j]), ⋯⟩ else ⟨(FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φs[↑j])) (FieldSpecification.WickAlgebra.ofFieldOp φ), ⋯⟩) * φsΛ.staticContractWickContraction.staticContract_insert_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : { x // x ∈ φsΛ.uncontracted }) : (WickContraction.insertAndContract φ φsΛ i (some j)).staticContract = (if i < i.succAbove ↑j then ⟨(FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φ)) (FieldSpecification.WickAlgebra.ofFieldOp φs[↑j]), ⋯⟩ else ⟨(FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φs[↑j])) (FieldSpecification.WickAlgebra.ofFieldOp φ), ⋯⟩) * φsΛ.staticContract
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted, then
(φsΛ ↩Λ φ i (some k)).staticContract is equal to the product of
[anPart φ, φs[k]]ₛ if i ≤ k or [anPart φs[k], φ]ₛ if k < i
φsΛ.staticContract.
The proof of this result ultimately is a consequence of definitions.
WickContraction.staticWickTerm {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.WickAlgebraWickContraction.staticWickTerm {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.WickAlgebra
For a list φs of 𝓕.FieldOp, and a Wick contraction φsΛ of φs, the element
of 𝓕.WickAlgebra, φsΛ.staticWickTerm is defined as
φsΛ.sign • φsΛ.staticContract * 𝓝([φsΛ]ᵘᶜ).
This is a term which appears in the static version Wick's theorem.
WickContraction.staticWickTerm_empty_nil {𝓕 : FieldSpecification} : WickContraction.empty.staticWickTerm = 1WickContraction.staticWickTerm_empty_nil {𝓕 : FieldSpecification} : WickContraction.empty.staticWickTerm = 1
For the empty list [] of 𝓕.FieldOp, the staticWickTerm of the Wick contraction
corresponding to the empty set ∅ (the only Wick contraction of []) is 1.
WickContraction.staticWickTerm_insert_zero_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : (WickContraction.insertAndContract φ φsΛ 0 none).staticWickTerm = WickContraction.sign φs φsΛ • ↑φsΛ.staticContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet))WickContraction.staticWickTerm_insert_zero_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : (WickContraction.insertAndContract φ φsΛ 0 none).staticWickTerm = WickContraction.sign φs φsΛ • ↑φsΛ.staticContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, and an element φ of
𝓕.FieldOp, then (φsΛ ↩Λ φ 0 none).staticWickTerm is equal to
φsΛ.sign • φsΛ.staticWickTerm * 𝓝(φ :: [φsΛ]ᵘᶜ)
The proof of this result relies on
staticContract_insert_none to rewrite the static contract.
sign_insert_none_zero to rewrite the sign.
WickContraction.staticWickTerm_insert_zero_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) : (WickContraction.insertAndContract φ φsΛ 0 (some k)).staticWickTerm = WickContraction.sign φs φsΛ • (↑φsΛ.staticContract * (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k))))))WickContraction.staticWickTerm_insert_zero_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) : (WickContraction.insertAndContract φ φsΛ 0 (some k)).staticWickTerm = WickContraction.sign φs φsΛ • (↑φsΛ.staticContract * (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k))))))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, and a k in φsΛ.uncontracted, (φsΛ ↩Λ φ 0 (some k)).wickTerm is equal
to the product of
the sign 𝓢(φ, φ₀…φᵢ₋₁)
the sign φsΛ.sign
φsΛ.staticContract
s • [anPart φ, ofFieldOp φs[k]]ₛ where s is the sign associated with moving φ through
uncontracted fields in φ₀…φₖ₋₁
the normal ordering of [φsΛ]ᵘᶜ with the field operator φs[k] removed.
The proof of this result ultimately relies on
staticContract_insert_some to rewrite static contractions.
normalOrder_uncontracted_some to rewrite normal orderings.
sign_insert_some_zero to rewrite signs.
WickContraction.mul_staticWickTerm_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : FieldSpecification.WickAlgebra.ofFieldOp φ * φsΛ.staticWickTerm = ∑ k, (WickContraction.insertAndContract φ φsΛ 0 k).staticWickTermWickContraction.mul_staticWickTerm_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : FieldSpecification.WickAlgebra.ofFieldOp φ * φsΛ.staticWickTerm = ∑ k, (WickContraction.insertAndContract φ φsΛ 0 k).staticWickTerm
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, the following relation
holds
φ * φsΛ.staticWickTerm = ∑ k, (φsΛ ↩Λ φ 0 k).staticWickTerm
where the sum is over all k in Option φsΛ.uncontracted, so k is either none or some k.
The proof proceeds as follows:
ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum is used to expand φ 𝓝([φsΛ]ᵘᶜ) as
a sum over k in Option φsΛ.uncontracted of terms involving [anPart φ, φs[k]]ₛ.
Then staticWickTerm_insert_zero_none and staticWickTerm_insert_zero_some are
used to equate terms.
FieldSpecification.WickAlgebra.static_wick_theorem {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOpList φs = ∑ φsΛ, φsΛ.staticWickTermFieldSpecification.WickAlgebra.static_wick_theorem {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.ofFieldOpList φs = ∑ φsΛ, φsΛ.staticWickTerm
For a list φs of 𝓕.FieldOp, the static version of Wick's theorem states that
φs = ∑ φsΛ, φsΛ.staticWickTerm
where the sum is over all Wick contraction φsΛ.
The proof is via induction on φs.
The base case φs = [] is handled by staticWickTerm_empty_nil.
The inductive step works as follows:
For the LHS:
The proof considers φ₀…φₙ as φ₀(φ₁…φₙ) and uses the induction hypothesis on φ₁…φₙ.
This gives terms of the form φ * φsΛ.staticWickTerm on which
mul_staticWickTerm_eq_sum is used where φsΛ is a Wick contraction of φ₁…φₙ,
to rewrite terms as a sum over optional uncontracted elements of φsΛ
On the LHS we now have a sum over Wick contractions φsΛ of φ₁…φₙ (from 1) and optional
uncontracted elements of φsΛ (from 2)
For the RHS:
The sum over Wick contractions of φ₀…φₙ on the RHS
is split via insertLift_sum into a sum over Wick contractions φsΛ of φ₁…φₙ and
sum over optional uncontracted elements of φsΛ.
Both sides are now sums over the same thing and their terms equate by the nature of the lemmas used.
FieldSpecification.WickAlgebra.timeContract {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) : 𝓕.WickAlgebraFieldSpecification.WickAlgebra.timeContract {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) : 𝓕.WickAlgebra
For a field specification 𝓕, and φ and ψ elements of 𝓕.FieldOp, the element of
𝓕.WickAlgebra, timeContract φ ψ is defined to be 𝓣(φψ) - 𝓝(φψ).
FieldSpecification.WickAlgebra.timeContract_of_timeOrderRel {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) (h : FieldSpecification.timeOrderRel φ ψ) : FieldSpecification.WickAlgebra.timeContract φ ψ = (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φ)) (FieldSpecification.WickAlgebra.ofFieldOp ψ)FieldSpecification.WickAlgebra.timeContract_of_timeOrderRel {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) (h : FieldSpecification.timeOrderRel φ ψ) : FieldSpecification.WickAlgebra.timeContract φ ψ = (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart φ)) (FieldSpecification.WickAlgebra.ofFieldOp ψ)
For a field specification 𝓕, and φ and ψ elements of 𝓕.FieldOp, if
φ and ψ are time-ordered then
timeContract φ ψ = [anPart φ, ofFieldOp ψ]ₛ.
FieldSpecification.WickAlgebra.timeContract_of_not_timeOrderRel_expand {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) (h : ¬FieldSpecification.timeOrderRel φ ψ) : FieldSpecification.WickAlgebra.timeContract φ ψ = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (𝓕.fieldOpStatistic ψ) • (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart ψ)) (FieldSpecification.WickAlgebra.ofFieldOp φ)FieldSpecification.WickAlgebra.timeContract_of_not_timeOrderRel_expand {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) (h : ¬FieldSpecification.timeOrderRel φ ψ) : FieldSpecification.WickAlgebra.timeContract φ ψ = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (𝓕.fieldOpStatistic ψ) • (FieldSpecification.WickAlgebra.superCommute (FieldSpecification.WickAlgebra.anPart ψ)) (FieldSpecification.WickAlgebra.ofFieldOp φ)
For a field specification 𝓕, and φ and ψ elements of 𝓕.FieldOp, if
φ and ψ are not time-ordered then
timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • [anPart ψ, ofFieldOp φ]ₛ.
FieldSpecification.WickAlgebra.timeContract_mem_center {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeContract φ ψ ∈ Subalgebra.center ℂ 𝓕.WickAlgebraFieldSpecification.WickAlgebra.timeContract_mem_center {𝓕 : FieldSpecification} (φ ψ : 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeContract φ ψ ∈ Subalgebra.center ℂ 𝓕.WickAlgebra
For a field specification 𝓕, and φ and ψ elements of 𝓕.FieldOp, then
timeContract φ ψ is in the center of 𝓕.WickAlgebra.
WickContraction.timeContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : ↥(Subalgebra.center ℂ 𝓕.WickAlgebra)WickContraction.timeContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : ↥(Subalgebra.center ℂ 𝓕.WickAlgebra)
For a list φs of 𝓕.FieldOp and a Wick contraction φsΛ the
element of the center of 𝓕.WickAlgebra, φsΛ.timeContract is defined as the product
of timeContract φs[j] φs[k] over contracted pairs {j, k} in φsΛ
with j < k.
WickContraction.timeContract_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (WickContraction.insertAndContract φ φsΛ i none).timeContract = φsΛ.timeContractWickContraction.timeContract_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (WickContraction.insertAndContract φ φsΛ i none).timeContract = φsΛ.timeContract
WickContraction.timeContract_insert_some_of_not_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (ht : ¬FieldSpecification.timeOrderRel φs[↑k] φ) (hik : ¬i < i.succAbove ↑k) : ↑(WickContraction.insertAndContract φ φsΛ i (some k)).timeContract = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x ≤ ↑k})) • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract)WickContraction.timeContract_insert_some_of_not_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (ht : ¬FieldSpecification.timeOrderRel φs[↑k] φ) (hik : ¬i < i.succAbove ↑k) : ↑(WickContraction.insertAndContract φ φsΛ i (some k)).timeContract = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x ≤ ↑k})) • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract)
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted such that k < i, with the
condition that φs[k] does not have time greater or equal to φ, then
(φsΛ ↩Λ φ i (some k)).timeContract is equal to the product of
[anPart φ, φs[k]]ₛ
φsΛ.timeContract
the exchange sign of φ with the uncontracted fields in φ₀…φₖ₋₁.
the exchange sign of φ with the uncontracted fields in φ₀…φₖ.
The proof of this result ultimately is a consequence of definitions and
timeContract_of_not_timeOrderRel_expand.
WickContraction.timeContract_insert_some_of_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (ht : FieldSpecification.timeOrderRel φ φs[↑k]) (hik : i < i.succAbove ↑k) : ↑(WickContraction.insertAndContract φ φsΛ i (some k)).timeContract = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract)WickContraction.timeContract_insert_some_of_lt {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : { x // x ∈ φsΛ.uncontracted }) (ht : FieldSpecification.timeOrderRel φ φs[↑k]) (hik : i < i.succAbove ↑k) : ↑(WickContraction.insertAndContract φ φsΛ i (some k)).timeContract = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get ({x ∈ φsΛ.uncontracted | x < ↑k})) • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract)
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, a i ≤ φs.length and a k in φsΛ.uncontracted such that i ≤ k, with the
condition that φ has greater or equal time to φs[k], then
(φsΛ ↩Λ φ i (some k)).timeContract is equal to the product of
[anPart φ, φs[k]]ₛ
φsΛ.timeContract
two copies of the exchange sign of φ with the uncontracted fields in φ₀…φₖ₋₁.
These two exchange signs cancel each other out but are included for convenience.
The proof of this result ultimately is a consequence of definitions and
timeContract_of_timeOrderRel.
WickContraction.join_sign_timeContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) : WickContraction.sign φs (φsΛ.join φsucΛ) • ↑(φsΛ.join φsucΛ).timeContract = WickContraction.sign φs φsΛ • ↑φsΛ.timeContract * WickContraction.sign φsΛ.uncontractedListGet φsucΛ • ↑φsucΛ.timeContractWickContraction.join_sign_timeContract {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction φsΛ.uncontractedListGet.length) : WickContraction.sign φs (φsΛ.join φsucΛ) • ↑(φsΛ.join φsucΛ).timeContract = WickContraction.sign φs φsΛ • ↑φsΛ.timeContract * WickContraction.sign φsΛ.uncontractedListGet φsucΛ • ↑φsucΛ.timeContract
For a list φs of 𝓕.FieldOp, a Wick contraction φsΛ of φs,
and a Wick contraction φsucΛ of [φsΛ]ᵘᶜ,
(join φsΛ φsucΛ).sign • (join φsΛ φsucΛ).timeContract is equal to the product of
φsΛ.sign • φsΛ.timeContract and
φsucΛ.sign • φsucΛ.timeContract.
WickContraction.wickTerm {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.WickAlgebraWickContraction.wickTerm {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.WickAlgebra
For a list φs of 𝓕.FieldOp, and a Wick contraction φsΛ of φs, the element
of 𝓕.WickAlgebra, φsΛ.wickTerm is defined as
φsΛ.sign • φsΛ.timeContract * 𝓝([φsΛ]ᵘᶜ).
This is a term which appears in the Wick's theorem.
For the empty list [] of 𝓕.FieldOp, the wickTerm of the Wick contraction
corresponding to the empty set ∅ (the only Wick contraction of []) is 1.
WickContraction.wickTerm_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : (WickContraction.insertAndContract φ φsΛ i none).wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {k | i.succAbove k < i}) • (WickContraction.sign φs φsΛ • ↑φsΛ.timeContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet)))WickContraction.wickTerm_insert_none {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : (WickContraction.insertAndContract φ φsΛ i none).wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {k | i.succAbove k < i}) • (WickContraction.sign φs φsΛ • ↑φsΛ.timeContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (φ :: φsΛ.uncontractedListGet)))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, and i ≤ φs.length, then (φsΛ ↩Λ φ i none).wickTerm is equal to
𝓢(φ, φ₀…φᵢ₋₁) φsΛ.sign • φsΛ.timeContract * 𝓝(φ :: [φsΛ]ᵘᶜ)
The proof of this result relies on
normalOrder_uncontracted_none to rewrite normal orderings.
timeContract_insert_none to rewrite the time contract.
sign_insert_none to rewrite the sign.
WickContraction.wickTerm_insert_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) (hlt : ∀ (k : Fin φs.length), FieldSpecification.timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬FieldSpecification.timeOrderRel φs[k] φ) : (WickContraction.insertAndContract φ φsΛ i (some k)).wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) • (WickContraction.sign φs φsΛ • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)))))WickContraction.wickTerm_insert_some {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) (hlt : ∀ (k : Fin φs.length), FieldSpecification.timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬FieldSpecification.timeOrderRel φs[k] φ) : (WickContraction.insertAndContract φ φsΛ i (some k)).wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) • (WickContraction.sign φs φsΛ • (FieldSpecification.WickAlgebra.contractStateAtIndex φ φsΛ.uncontractedListGet ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)) * ↑φsΛ.timeContract) * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (PhysLean.List.optionEraseZ φsΛ.uncontractedListGet φ ((WickContraction.uncontractedFieldOpEquiv φs φsΛ) (some k)))))
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, i ≤ φs.length and a k in φsΛ.uncontracted,
such that all 𝓕.FieldOp in φ₀…φᵢ₋₁ have time strictly less than φ and
φ has a time greater than or equal to all FieldOp in φ₀…φₙ, then
(φsΛ ↩Λ φ i (some k)).staticWickTerm
is equal to the product of
the sign 𝓢(φ, φ₀…φᵢ₋₁)
the sign φsΛ.sign
φsΛ.timeContract
s • [anPart φ, ofFieldOp φs[k]]ₛ where s is the sign associated with moving φ through
uncontracted fields in φ₀…φₖ₋₁
the normal ordering [φsΛ]ᵘᶜ with the field corresponding to k removed.
The proof of this result relies on
timeContract_insert_some_of_not_lt
and timeContract_insert_some_of_lt to rewrite time
contractions.
normalOrder_uncontracted_some to rewrite normal orderings.
sign_insert_some_of_not_lt and sign_insert_some_of_lt to rewrite signs.
WickContraction.mul_wickTerm_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), FieldSpecification.timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬FieldSpecification.timeOrderRel φs[k] φ) : FieldSpecification.WickAlgebra.ofFieldOp φ * φsΛ.wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) • ∑ k, (WickContraction.insertAndContract φ φsΛ i k).wickTermWickContraction.mul_wickTerm_eq_sum {𝓕 : FieldSpecification} (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), FieldSpecification.timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬FieldSpecification.timeOrderRel φs[k] φ) : FieldSpecification.WickAlgebra.ofFieldOp φ * φsΛ.wickTerm = (FieldStatistic.exchangeSign (𝓕.fieldOpStatistic φ)) (FieldStatistic.ofFinset 𝓕.fieldOpStatistic φs.get {x | i.succAbove x < i}) • ∑ k, (WickContraction.insertAndContract φ φsΛ i k).wickTerm
For a list φs = φ₀…φₙ of 𝓕.FieldOp, a Wick contraction φsΛ of φs, an element φ of
𝓕.FieldOp, and i ≤ φs.length
such that all 𝓕.FieldOp in φ₀…φᵢ₋₁ have time strictly less than φ and
φ has a time greater than or equal to all FieldOp in φ₀…φₙ, then
φ * φsΛ.wickTerm = 𝓢(φ, φ₀…φᵢ₋₁) • ∑ k, (φsΛ ↩Λ φ i k).wickTerm
where the sum is over all k in Option φsΛ.uncontracted, so k is either none or some k.
The proof proceeds as follows:
ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum is used to expand φ 𝓝([φsΛ]ᵘᶜ) as
a sum over k in Option φsΛ.uncontracted of terms involving [anPart φ, φs[k]]ₛ.
Then wickTerm_insert_none and wickTerm_insert_some are used to equate terms.
FieldSpecification.wicks_theorem {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, φsΛ.wickTermFieldSpecification.wicks_theorem {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, φsΛ.wickTerm
For a list φs of 𝓕.FieldOp, Wick's theorem states that
𝓣(φs) = ∑ φsΛ, φsΛ.wickTerm
where the sum is over all Wick contraction φsΛ.
The proof is via induction on φs.
The base case φs = [] is handled by wickTerm_empty_nil.
The inductive step works as follows:
For the LHS:
timeOrder_eq_maxTimeField_mul_finset is used to write
𝓣(φ₀…φₙ) as 𝓢(φᵢ,φ₀…φᵢ₋₁) • φᵢ * 𝓣(φ₀…φᵢ₋₁φᵢ₊₁φₙ) where φᵢ is
the maximal time field in φ₀…φₙ
The induction hypothesis is then used on 𝓣(φ₀…φᵢ₋₁φᵢ₊₁φₙ) to expand it as a sum over
Wick contractions of φ₀…φᵢ₋₁φᵢ₊₁φₙ.
This gives terms of the form φᵢ * φsΛ.wickTerm on which
mul_wickTerm_eq_sum is used where φsΛ is a Wick contraction of φ₀…φᵢ₋₁φᵢ₊₁φ,
to rewrite terms as a sum over optional uncontracted elements of φsΛ
On the LHS we now have a sum over Wick contractions φsΛ of φ₀…φᵢ₋₁φᵢ₊₁φ (from 2) and optional
uncontracted elements of φsΛ (from 3)
For the RHS:
The sum over Wick contractions of φ₀…φₙ on the RHS
is split via insertLift_sum into a sum over Wick contractions φsΛ of φ₀…φᵢ₋₁φᵢ₊₁φ and
sum over optional uncontracted elements of φsΛ.
Both sides are now sums over the same thing and their terms equate by the nature of the lemmas used.
WickContraction.EqTimeOnly.timeOrder_staticContract_of_not_mem {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : ¬φsΛ.EqTimeOnly) : FieldSpecification.WickAlgebra.timeOrder ↑φsΛ.staticContract = 0WickContraction.EqTimeOnly.timeOrder_staticContract_of_not_mem {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : ¬φsΛ.EqTimeOnly) : FieldSpecification.WickAlgebra.timeOrder ↑φsΛ.staticContract = 0
Let φs be a list of 𝓕.FieldOp and φsΛ a WickContraction with
at least one contraction between 𝓕.FieldOp that do not have the same time. Then
𝓣(φsΛ.staticContract.1) = 0.
WickContraction.EqTimeOnly.staticContract_eq_timeContract_of_eqTimeOnly {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (h : φsΛ.EqTimeOnly) : φsΛ.staticContract = φsΛ.timeContractWickContraction.EqTimeOnly.staticContract_eq_timeContract_of_eqTimeOnly {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (h : φsΛ.EqTimeOnly) : φsΛ.staticContract = φsΛ.timeContract
Let φs be a list of 𝓕.FieldOp and φsΛ a WickContraction of φs within
which every contraction involves two 𝓕.FieldOps that have the same time, then
φsΛ.staticContract = φsΛ.timeContract.
WickContraction.EqTimeOnly.timeOrder_timeContract_mul_of_eqTimeOnly_left {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : φsΛ.EqTimeOnly) (b : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.timeOrder (↑φsΛ.timeContract * b) = ↑φsΛ.timeContract * FieldSpecification.WickAlgebra.timeOrder bWickContraction.EqTimeOnly.timeOrder_timeContract_mul_of_eqTimeOnly_left {𝓕 : FieldSpecification} {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : φsΛ.EqTimeOnly) (b : 𝓕.WickAlgebra) : FieldSpecification.WickAlgebra.timeOrder (↑φsΛ.timeContract * b) = ↑φsΛ.timeContract * FieldSpecification.WickAlgebra.timeOrder b
Let φs be a list of 𝓕.FieldOp, φsΛ a WickContraction of φs within
which every contraction involves two 𝓕.FieldOps that have the same time and
b a general element in 𝓕.WickAlgebra. Then
𝓣(φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(b).
This follows from properties of orderings and the ideal defining 𝓕.WickAlgebra.
FieldSpecification.WickAlgebra.timeOrder_ofFieldOpList_eqTimeOnly {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet))FieldSpecification.WickAlgebra.timeOrder_ofFieldOpList_eqTimeOnly {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet))
For a list φs of 𝓕.FieldOp, then
𝓣(φs) = ∑ φsΛ, φsΛ.sign • φsΛ.timeContract * 𝓣(𝓝([φsΛ]ᵘᶜ))
where the sum is over all Wick contraction φsΛ which only have equal time contractions.
This result follows from
static_wick_theorem to rewrite 𝓣(φs) on the left hand side as a sum of
𝓣(φsΛ.staticWickTerm).
EqTimeOnly.timeOrder_staticContract_of_not_mem and timeOrder_timeOrder_mid to set to
those 𝓣(φsΛ.staticWickTerm) for which φsΛ has a contracted pair which are not
equal time to zero.
staticContract_eq_timeContract_of_eqTimeOnly to rewrite the static contract
in the remaining 𝓣(φsΛ.staticWickTerm) as a time contract.
timeOrder_timeContract_mul_of_eqTimeOnly_left to move the time contracts out of the time
ordering.
FieldSpecification.WickAlgebra.normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs)) = FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) - ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet))FieldSpecification.WickAlgebra.normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs)) = FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) - ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet))
For a list φs of 𝓕.FieldOp, then
𝓣(𝓝(φs)) = 𝓣(φs) - ∑ φsΛ, φsΛ.sign • φsΛ.timeContract.1 * 𝓣(𝓝([φsΛ]ᵘᶜ))
where the sum is over all non-empty Wick contraction φsΛ which only
have equal time contractions.
This result follows directly from
timeOrder_ofFieldOpList_eqTimeOnly
FieldSpecification.WickAlgebra.timeOrder_haveEqTime_split {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet) + ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * ∑ φssucΛ, (↑φssucΛ).wickTermFieldSpecification.WickAlgebra.timeOrder_haveEqTime_split {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs) = ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList (↑φsΛ).uncontractedListGet) + ∑ φsΛ, WickContraction.sign φs ↑φsΛ • ↑(↑φsΛ).timeContract * ∑ φssucΛ, (↑φssucΛ).wickTerm
For a list φs of 𝓕.FieldOp, then 𝓣(φs) is equal to the sum of
∑ φsΛ, φsΛ.wickTerm where the sum is over all Wick contraction φsΛ which have
no contractions of equal time.
∑ φsΛ, φsΛ.sign • φsΛ.timeContract * (∑ φssucΛ, φssucΛ.wickTerm), where
the first sum is over all Wick contraction φsΛ which only have equal time contractions
and the second sum is over all Wick contraction φssucΛ of the uncontracted elements of φsΛ
which do not have any equal time contractions.
The proof proceeds as follows
wicks_theorem is used to rewrite 𝓣(φs) as a sum over all Wick contractions.
The sum over all Wick contractions is then split additively into two parts based on having or not having an equal time contractions.
Using join, the sum ∑ φsΛ, _ over Wick contractions which do have equal time contractions
is split into two sums ∑ φsΛ, ∑ φsucΛ, _, the first over non-zero elements
which only have equal time contractions and the second over Wick contractions φsucΛ of
[φsΛ]ᵘᶜ which do not have equal time contractions.
join_sign_timeContract is then used to equate terms.
FieldSpecification.WickAlgebra.wicks_theorem_normal_order {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs)) = ∑ φsΛ, (↑φsΛ).wickTermFieldSpecification.WickAlgebra.wicks_theorem_normal_order {𝓕 : FieldSpecification} (φs : List 𝓕.FieldOp) : FieldSpecification.WickAlgebra.timeOrder (FieldSpecification.WickAlgebra.normalOrder (FieldSpecification.WickAlgebra.ofFieldOpList φs)) = ∑ φsΛ, (↑φsΛ).wickTerm
For a list φs of 𝓕.FieldOp, the normal-ordered version of Wick's theorem states that
𝓣(𝓝(φs)) = ∑ φsΛ, φsΛ.wickTerm
where the sum is over all Wick contraction φsΛ in which no two contracted elements
have the same time.
The proof proceeds by induction on φs, with the base case [] holding by following
through definitions. and the inductive case holding as a result of
timeOrder_haveEqTime_split
normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty
and the induction hypothesis on 𝓣(𝓝([φsΛ.1]ᵘᶜ)) for contractions φsΛ of φs which only
have equal time contractions and are non-empty.