title: "Proof of Wick's theorem" curators: Joseph Tooby-Smith parts: - type: h1 sectionNo: 1 content: "Introduction" - type: remark name: "wicks_theorem_context" status : "incomplete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheorem.lean#L49" content: | In perturbative quantum field theory, Wick's theorem allows us to expand expectation values of time-ordered products of fields in terms of normal-orders and time contractions. The theorem is used to simplify the calculation of scattering amplitudes, and is the precurser to Feynman diagrams. There are actually three different versions of Wick's theorem used. The static version, the time-dependent version, and the normal-ordered time-dependent version. PhysLean contains a formalization of all three of these theorems in complete generality for mixtures of bosonic and fermionic fields. The statement of these theorems for bosons is simplier then when fermions are involved, since one does not have to worry about the minus-signs picked up on exchanging fields. - type: p content: "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 statitics, 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." - type: p content: " 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." - type: h1 sectionNo: 2 content: "Field operators" - type: h2 sectionNo: "2.1" content: "Field statistics" - type: name name: FieldStatistic line: 18 fileName: PhysLean.QFT.PerturbationTheory.FieldStatistics.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldStatistics/Basic.lean#L18" isDef: true isThm: false docString: | 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. declString: | inductive FieldStatistic : Type where | bosonic : FieldStatistic | fermionic : FieldStatistic deriving DecidableEq declNo: "2.1" - type: name name: FieldStatistic.instCommGroup line: 29 fileName: PhysLean.QFT.PerturbationTheory.FieldStatistics.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldStatistics/Basic.lean#L29" isDef: true isThm: false docString: | 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 `ℤ₂`. declString: | instance : CommGroup FieldStatistic where one := bosonic mul a b := match a, b with | bosonic, bosonic => bosonic | bosonic, fermionic => fermionic | fermionic, bosonic => fermionic | fermionic, fermionic => bosonic inv a := a mul_assoc a b c := by cases a <;> cases b <;> cases c <;> dsimp [HMul.hMul] one_mul a := by cases a <;> dsimp [HMul.hMul] mul_one a := by cases a <;> dsimp [HMul.hMul] inv_mul_cancel a := by cases a <;> dsimp only [HMul.hMul, Nat.succ_eq_add_one] <;> rfl mul_comm a b := by cases a <;> cases b <;> rfl declNo: "2.2" - type: name name: FieldStatistic.exchangeSign line: 27 fileName: PhysLean.QFT.PerturbationTheory.FieldStatistics.ExchangeSign status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldStatistics/ExchangeSign.lean#L27" isDef: true isThm: false docString: | 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`. declString: | def exchangeSign : FieldStatistic →* FieldStatistic →* ℂ where toFun a := { toFun := fun b => match a, b with | bosonic, _ => 1 | _, bosonic => 1 | fermionic, fermionic => -1 map_one' := by fin_cases a <;> simp map_mul' := fun c b => by fin_cases a <;> fin_cases b <;> fin_cases c <;> simp } map_one' := by ext b fin_cases b <;> simp map_mul' c b := by ext a fin_cases a <;> fin_cases b <;> fin_cases c <;> simp declNo: "2.3" - type: h2 sectionNo: "2.2" content: "Field specifications" - type: name name: FieldSpecification line: 32 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/Basic.lean#L32" isDef: true isThm: false docString: | 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`. declString: | structure FieldSpecification where /-- A type whose elements are the constituent fields of the theory. -/ 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`. -/ PositionLabel : 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`. -/ AsymptoticLabel : Field → Type /-- For every field `f` in `Field`, the field statistic `statistic f` classifies `f` as either `bosonic` or `fermionic`. -/ statistic : Field → FieldStatistic declNo: "2.4" - type: h2 sectionNo: "2.3" content: "Field operators" - type: name name: FieldSpecification.FieldOp line: 72 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/Basic.lean#L72" isDef: true isThm: false docString: | 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)`. declString: | inductive FieldOp (𝓕 : FieldSpecification) where | inAsymp : (Σ f, 𝓕.AsymptoticLabel f) × (Fin 3 → ℝ) → 𝓕.FieldOp | position : (Σ f, 𝓕.PositionLabel f) × SpaceTime → 𝓕.FieldOp | outAsymp : (Σ f, 𝓕.AsymptoticLabel f) × (Fin 3 → ℝ) → 𝓕.FieldOp declNo: "2.5" - type: name name: FieldSpecification.fieldOpStatistic line: 115 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/Basic.lean#L115" isDef: true isThm: false docString: | 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`: - For `φ` an element of `𝓕.FieldOp`, `𝓕 |>ₛ φ` is `fieldOpStatistic φ`. - For `φs` a list of `𝓕.FieldOp`, `𝓕 |>ₛ φs` is the product of `fieldOpStatistic φ` over the list `φs`. - For a function `f : Fin n → 𝓕.FieldOp` and a finite set `a` of `Fin n`, `𝓕 |>ₛ ⟨f, a⟩` is the product of `fieldOpStatistic (f i)` for all `i ∈ a`. declString: | def fieldOpStatistic : 𝓕.FieldOp → FieldStatistic := 𝓕.statistic ∘ 𝓕.fieldOpToField declNo: "2.6" - type: name name: CreateAnnihilate line: 13 fileName: PhysLean.QFT.PerturbationTheory.CreateAnnihilate status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/CreateAnnihilate.lean#L13" isDef: true isThm: false docString: | 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 thereover etc. declString: | inductive CreateAnnihilate where | create : CreateAnnihilate | annihilate : CreateAnnihilate deriving Inhabited, BEq, DecidableEq declNo: "2.7" - type: name name: FieldSpecification.CrAnFieldOp line: 65 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.CrAnFieldOp status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/CrAnFieldOp.lean#L65" isDef: true isThm: false docString: | 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)`. declString: | def CrAnFieldOp : Type := Σ (s : 𝓕.FieldOp), 𝓕.fieldOpToCrAnType s declNo: "2.8" - type: name name: FieldSpecification.crAnFieldOpToCreateAnnihilate line: 103 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.CrAnFieldOp status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/CrAnFieldOp.lean#L103" isDef: true isThm: false docString: | 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`. declString: | def crAnFieldOpToCreateAnnihilate : 𝓕.CrAnFieldOp → CreateAnnihilate | ⟨FieldOp.inAsymp _, _⟩ => CreateAnnihilate.create | ⟨FieldOp.position _, CreateAnnihilate.create⟩ => CreateAnnihilate.create | ⟨FieldOp.position _, CreateAnnihilate.annihilate⟩ => CreateAnnihilate.annihilate | ⟨FieldOp.outAsymp _, _⟩ => CreateAnnihilate.annihilate declNo: "2.9" - type: name name: FieldSpecification.crAnStatistics line: 116 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.CrAnFieldOp status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/CrAnFieldOp.lean#L116" isDef: true isThm: false docString: | 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`, `𝓕 |>ₛ φ` is `crAnStatistics φ`. - For `φs` a list of `𝓕.CrAnFieldOp`, `𝓕 |>ₛ φs` is the product of `crAnStatistics φ` over the list `φs`. declString: | def crAnStatistics : 𝓕.CrAnFieldOp → FieldStatistic := 𝓕.fieldOpStatistic ∘ 𝓕.crAnFieldOpToFieldOp declNo: "2.10" - type: remark name: "notation_remark" status : "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/CrAnFieldOp.lean#L141" content: | When working with a field specification `𝓕` the following notation will be used within doc-strings: - when field statistics occur in exchange signs the `𝓕 |>ₛ _` may be dropped. - lists of `FieldOp` or `CrAnFieldOp` `φs` may be written as `φ₀…φₙ`, which should be interpreted within the context in which it appears. - `φᶜ` may be used to indicate the creation part of an operator and `φᵃ` to indicate the annihilation part of an operator. Some examples of these notation-conventions are: - `𝓢(φ, φs)` which corresponds to `𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ φs)` - `φ₀…φᵢ₋₁φᵢ₊₁…φₙ` which corresponds to a (given) list `φs = φ₀…φₙ` with the element at the `i`th position removed. - type: h2 sectionNo: "2.4" content: "Field-operator free algebra" - type: name name: FieldSpecification.FieldOpFreeAlgebra line: 37 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L37" isDef: true isThm: false docString: | For a field specification `𝓕`, the algebra `𝓕.FieldOpFreeAlgebra` is the free algebra generated by `𝓕.CrAnFieldOp`. declString: | abbrev FieldOpFreeAlgebra (𝓕 : FieldSpecification) : Type := FreeAlgebra ℂ 𝓕.CrAnFieldOp declNo: "2.11" - type: remark name: "naming_convention" status : "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L43" content: | For mathematicial objects defined in relation to `FieldOpFreeAlgebra` the postfix `F` may be given to their names to indicate that they are related to the free algebra. This is to avoid confusion when working within the context of `FieldOpAlgebra` which is defined as a quotient of `FieldOpFreeAlgebra`. - type: name name: FieldSpecification.FieldOpFreeAlgebra.ofCrAnOpF line: 50 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L50" isDef: true isThm: false docString: | For a field specification `𝓕`, and a element `φ` of `𝓕.CrAnFieldOp`, `ofCrAnOpF φ` is defined as the element of `𝓕.FieldOpFreeAlgebra` formed by `φ`. declString: | def ofCrAnOpF (φ : 𝓕.CrAnFieldOp) : FieldOpFreeAlgebra 𝓕 := FreeAlgebra.ι ℂ φ declNo: "2.12" - type: name name: FieldSpecification.FieldOpFreeAlgebra.universality line: 55 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L55" isDef: false isThm: false docString: | 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`. declString: | lemma universality {A : Type} [Semiring A] [Algebra ℂ A] (f : 𝓕.CrAnFieldOp → A) : ∃! g : FieldOpFreeAlgebra 𝓕 →ₐ[ℂ] A, g ∘ ofCrAnOpF = f := by use FreeAlgebra.lift ℂ f apply And.intro · funext x simp [ofCrAnOpF] · intro g hg ext x simpa using congrFun hg x declNo: "2.13" - type: name name: FieldSpecification.FieldOpFreeAlgebra.ofCrAnListF line: 74 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L74" isDef: true isThm: false docString: | 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 𝓕`. declString: | def ofCrAnListF (φs : List 𝓕.CrAnFieldOp) : FieldOpFreeAlgebra 𝓕 := (List.map ofCrAnOpF φs).prod declNo: "2.14" - type: name name: FieldSpecification.FieldOpFreeAlgebra.ofFieldOpF line: 94 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L94" isDef: true isThm: false docString: | 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⟩`. declString: | def ofFieldOpF (φ : 𝓕.FieldOp) : FieldOpFreeAlgebra 𝓕 := ∑ (i : 𝓕.fieldOpToCrAnType φ), ofCrAnOpF ⟨φ, i⟩ declNo: "2.15" - type: name name: FieldSpecification.FieldOpFreeAlgebra.ofFieldOpListF line: 105 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L105" isDef: true isThm: false docString: | 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 φ₃`. declString: | def ofFieldOpListF (φs : List 𝓕.FieldOp) : FieldOpFreeAlgebra 𝓕 := (List.map ofFieldOpF φs).prod declNo: "2.16" - type: remark name: "notation_drop" status : "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Basic.lean#L111" content: | In doc-strings explicit applications of `ofCrAnOpF`, `ofCrAnListF`, `ofFieldOpF`, and `ofFieldOpListF` will often be dropped. - type: name name: FieldSpecification.FieldOpFreeAlgebra.fieldOpFreeAlgebraGrade line: 239 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.Grading status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/Grading.lean#L239" isDef: true isThm: false docString: | 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 = bosonic`) span `bosonic` submodule, whilst those `ofCrAnListF φs` for which `φs` has an overall `fermionic` statistic (i.e. `𝓕 |>ₛ φs = fermionic`) span the `fermionic` submodule. declString: | instance fieldOpFreeAlgebraGrade : GradedAlgebra (A := 𝓕.FieldOpFreeAlgebra) statisticSubmodule where one_mem := by simp only [statisticSubmodule] refine Submodule.mem_span.mpr fun p a => a ?_ simp only [Set.mem_setOf_eq] use [] simp only [ofCrAnListF_nil, ofList_empty, true_and] rfl mul_mem f1 f2 a1 a2 h1 h2 := by let p (a2 : 𝓕.FieldOpFreeAlgebra) (hx : a2 ∈ statisticSubmodule f2) : Prop := a1 * a2 ∈ statisticSubmodule (f1 + f2) change p a2 h2 apply Submodule.span_induction (p := p) · intro x hx simp only [Set.mem_setOf_eq] at hx obtain ⟨φs, rfl, h⟩ := hx simp only [p] let p (a1 : 𝓕.FieldOpFreeAlgebra) (hx : a1 ∈ statisticSubmodule f1) : Prop := a1 * ofCrAnListF φs ∈ statisticSubmodule (f1 + f2) change p a1 h1 apply Submodule.span_induction (p := p) · intro y hy obtain ⟨φs', rfl, h'⟩ := hy simp only [p] rw [← ofCrAnListF_append] refine Submodule.mem_span.mpr fun p a => a ?_ simp only [Set.mem_setOf_eq] use φs' ++ φs simp only [ofList_append, h', h, true_and] cases f1 <;> cases f2 <;> rfl · simp [p] · intro x y hx hy hx1 hx2 simp only [add_mul, p] exact Submodule.add_mem _ hx1 hx2 · intro c a hx h1 simp only [Algebra.smul_mul_assoc, p] exact Submodule.smul_mem _ _ h1 · exact h1 · simp [p] · intro x y hx hy hx1 hx2 simp only [mul_add, p] exact Submodule.add_mem _ hx1 hx2 · intro c a hx h1 simp only [Algebra.mul_smul_comm, p] exact Submodule.smul_mem _ _ h1 · exact h2 decompose' a := DirectSum.of (fun i => (statisticSubmodule (𝓕 := 𝓕) i)) bosonic (bosonicProjF a) + DirectSum.of (fun i => (statisticSubmodule (𝓕 := 𝓕) i)) fermionic (fermionicProjF a) left_inv a := by trans a.bosonicProjF + fermionicProjF a · simp · exact bosonicProjF_add_fermionicProjF a right_inv a := by rw [coeAddMonoidHom_apply_eq_bosonic_plus_fermionic] simp only [DFinsupp.toFun_eq_coe, map_add, bosonicProjF_of_bonosic_part, bosonicProjF_of_fermionic_part, add_zero, fermionicProjF_of_bosonic_part, fermionicProjF_of_fermionic_part, zero_add] conv_rhs => rw [directSum_eq_bosonic_plus_fermionic a] declNo: "2.17" - type: name name: FieldSpecification.FieldOpFreeAlgebra.superCommuteF line: 26 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.SuperCommute status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/SuperCommute.lean#L26" isDef: true isThm: false docString: | 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`. declString: | noncomputable def superCommuteF : 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra →ₗ[ℂ] 𝓕.FieldOpFreeAlgebra := Basis.constr ofCrAnListFBasis ℂ fun φs => Basis.constr ofCrAnListFBasis ℂ fun φs' => ofCrAnListF (φs ++ φs') - 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs') • ofCrAnListF (φs' ++ φs) declNo: "2.18" - type: name name: FieldSpecification.FieldOpFreeAlgebra.superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum line: 408 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.SuperCommute status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/SuperCommute.lean#L408" isDef: false isThm: false docString: | 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`. declString: | lemma superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum (φs : List 𝓕.CrAnFieldOp) : (φs' : List 𝓕.CrAnFieldOp) → [ofCrAnListF φs, ofCrAnListF φs']ₛF = ∑ (n : Fin φs'.length), 𝓢(𝓕 |>ₛ φs, 𝓕 |>ₛ φs'.take n) • ofCrAnListF (φs'.take n) * [ofCrAnListF φs, ofCrAnOpF (φs'.get n)]ₛF * ofCrAnListF (φs'.drop (n + 1)) | [] => by simp [← ofCrAnListF_nil, superCommuteF_ofCrAnListF_ofCrAnListF] | φ :: φs' => by rw [superCommuteF_ofCrAnListF_ofCrAnListF_cons, superCommuteF_ofCrAnListF_ofCrAnListF_eq_sum φs φs'] conv_rhs => erw [Fin.sum_univ_succ] congr 1 · simp · simp [Finset.mul_sum, smul_smul, ofCrAnListF_cons, mul_assoc, FieldStatistic.ofList_cons_eq_mul, mul_comm] declNo: "2.19" - type: h2 sectionNo: "2.5" content: "Field-operator algebra" - type: name name: FieldSpecification.FieldOpAlgebra line: 35 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L35" isDef: true isThm: false docString: | For a field specification `𝓕`, the algebra `𝓕.FieldOpAlgebra` 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. declString: | abbrev FieldOpAlgebra : Type := (TwoSidedIdeal.span 𝓕.fieldOpIdealSet).ringCon.Quotient declNo: "2.20" - type: name name: FieldSpecification.FieldOpAlgebra.ι line: 73 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L73" isDef: true isThm: false docString: | For a field specification `𝓕`, `ι` is defined as the projection `𝓕.FieldOpFreeAlgebra →ₐ[ℂ] 𝓕.FieldOpAlgebra` taking each element of `𝓕.FieldOpFreeAlgebra` to its equivalence class in `FieldOpAlgebra 𝓕`. declString: | def ι : FieldOpFreeAlgebra 𝓕 →ₐ[ℂ] FieldOpAlgebra 𝓕 where toFun := (TwoSidedIdeal.span 𝓕.fieldOpIdealSet).ringCon.mk' map_one' := by rfl map_mul' x y := by rfl map_zero' := by rfl map_add' x y := by rfl commutes' x := by rfl declNo: "2.21" - type: name name: FieldSpecification.FieldOpAlgebra.universality line: 77 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Universality status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Universality.lean#L77" isDef: false isThm: false docString: | For a field specification, `𝓕`, the algebra `𝓕.FieldOpAlgebra` satisfies the following universal property. Let `f : 𝓕.CrAnFieldOp → A` be a function and `g : 𝓕.FieldOpFreeAlgebra →ₐ[ℂ] A` the universal lift of that function associated with the free algebra `𝓕.FieldOpFreeAlgebra`. If `g` is zero on the ideal defining `𝓕.FieldOpAlgebra`, then there exists algebra map `g' : FieldOpAlgebra 𝓕 →ₐ[ℂ] A` such that `g' ∘ ι = g`, and furthermore this algebra map is unique. declString: | lemma universality {A : Type} [Semiring A] [Algebra ℂ A] (f : 𝓕.CrAnFieldOp → A) (h1 : ∀ a ∈ TwoSidedIdeal.span 𝓕.fieldOpIdealSet, FreeAlgebra.lift ℂ f a = 0) : ∃! g : FieldOpAlgebra 𝓕 →ₐ[ℂ] A, g ∘ ι = FreeAlgebra.lift ℂ f := by use universalLift f h1 simp only apply And.intro · ext a simp · intro g hg ext a obtain ⟨a, rfl⟩ := ι_surjective a simpa using congrFun hg a declNo: "2.22" - type: name name: FieldSpecification.FieldOpAlgebra.ofCrAnOp line: 495 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L495" isDef: true isThm: false docString: | For a field specification `𝓕` and an element `φ` of `𝓕.CrAnFieldOp`, `ofCrAnOp φ` is defined as the element of `𝓕.FieldOpAlgebra` given by `ι (ofCrAnOpF φ)`. declString: | def ofCrAnOp (φ : 𝓕.CrAnFieldOp) : 𝓕.FieldOpAlgebra := ι (ofCrAnOpF φ) declNo: "2.23" - type: name name: FieldSpecification.FieldOpAlgebra.ofCrAnList line: 509 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L509" isDef: true isThm: false docString: | For a field specification `𝓕` and a list `φs` of `𝓕.CrAnFieldOp`, `ofCrAnList φs` is defined as the element of `𝓕.FieldOpAlgebra` given by `ι (ofCrAnListF φ)`. declString: | def ofCrAnList (φs : List 𝓕.CrAnFieldOp) : 𝓕.FieldOpAlgebra := ι (ofCrAnListF φs) declNo: "2.24" - type: name name: FieldSpecification.FieldOpAlgebra.ofFieldOp line: 463 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L463" isDef: true isThm: false docString: | For a field specification `𝓕` and an element `φ` of `𝓕.FieldOp`, `ofFieldOp φ` is defined as the element of `𝓕.FieldOpAlgebra` given by `ι (ofFieldOpF φ)`. declString: | def ofFieldOp (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (ofFieldOpF φ) declNo: "2.25" - type: name name: FieldSpecification.FieldOpAlgebra.ofCrAnList line: 509 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L509" isDef: true isThm: false docString: | For a field specification `𝓕` and a list `φs` of `𝓕.CrAnFieldOp`, `ofCrAnList φs` is defined as the element of `𝓕.FieldOpAlgebra` given by `ι (ofCrAnListF φ)`. declString: | def ofCrAnList (φs : List 𝓕.CrAnFieldOp) : 𝓕.FieldOpAlgebra := ι (ofCrAnListF φs) declNo: "2.26" - type: remark name: "notation_drop" status : "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L533" content: | In doc-strings we will often drop explicit applications of `ofCrAnOp`, `ofCrAnList`, `ofFieldOp`, and `ofFieldOpList` - type: name name: FieldSpecification.FieldOpAlgebra.anPart line: 536 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L536" isDef: true isThm: false docString: | For a field specification `𝓕`, and an element `φ` of `𝓕.FieldOp`, the annihilation part of `𝓕.FieldOp` as an element of `𝓕.FieldOpAlgebra`. Thus for `φ` - an incoming asymptotic state this is `0`. - a position based state this is `ofCrAnOp ⟨φ, .create⟩`. - an outgoing asymptotic state this is `ofCrAnOp ⟨φ, ()⟩`. declString: | def anPart (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (anPartF φ) declNo: "2.27" - type: name name: FieldSpecification.FieldOpAlgebra.crPart line: 562 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L562" isDef: true isThm: false docString: | For a field specification `𝓕`, and an element `φ` of `𝓕.FieldOp`, the creation part of `𝓕.FieldOp` as an element of `𝓕.FieldOpAlgebra`. Thus for `φ` - an incoming asymptotic state this is `ofCrAnOp ⟨φ, ()⟩`. - a position based state this is `ofCrAnOp ⟨φ, .create⟩`. - an outgoing asymptotic state this is `0`. declString: | def crPart (φ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := ι (crPartF φ) declNo: "2.28" - type: name name: FieldSpecification.FieldOpAlgebra.ofFieldOp_eq_crPart_add_anPart line: 588 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Basic.lean#L588" isDef: false isThm: false docString: | 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. declString: | lemma ofFieldOp_eq_crPart_add_anPart (φ : 𝓕.FieldOp) : ofFieldOp φ = crPart φ + anPart φ := by rw [ofFieldOp, crPart, anPart, ofFieldOpF_eq_crPartF_add_anPartF] simp only [map_add] declNo: "2.29" - type: name name: FieldSpecification.FieldOpAlgebra.fieldOpAlgebraGrade line: 386 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.Grading status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/Grading.lean#L386" isDef: true isThm: false docString: | For a field statistic `𝓕`, the algebra `𝓕.FieldOpAlgebra` is graded by `FieldStatistic`. Those `ofCrAnList φs` for which `φs` has an overall `bosonic` statistic (i.e. `𝓕 |>ₛ φs = bosonic`) span `bosonic` submodule, whilst those `ofCrAnList φs` for which `φs` has an overall `fermionic` statistic (i.e. `𝓕 |>ₛ φs = fermionic`) span the `fermionic` submodule. declString: | instance fieldOpAlgebraGrade : GradedAlgebra (A := 𝓕.FieldOpAlgebra) statSubmodule where one_mem := by simp only [statSubmodule] refine Submodule.mem_span.mpr fun p a => a ?_ simp only [Set.mem_setOf_eq] use [] simp only [ofCrAnList, ofCrAnListF_nil, map_one, ofList_empty, true_and] rfl mul_mem f1 f2 a1 a2 h1 h2 := by let p (a2 : 𝓕.FieldOpAlgebra) (hx : a2 ∈ statSubmodule f2) : Prop := a1 * a2 ∈ statSubmodule (f1 + f2) change p a2 h2 apply Submodule.span_induction · intro x hx simp only [Set.mem_setOf_eq] at hx obtain ⟨φs, rfl, h⟩ := hx simp only [p] let p (a1 : 𝓕.FieldOpAlgebra) (hx : a1 ∈ statSubmodule f1) : Prop := a1 * ofCrAnList φs ∈ statSubmodule (f1 + f2) change p a1 h1 apply Submodule.span_induction (p := p) · intro y hy obtain ⟨φs', rfl, h'⟩ := hy simp only [p] rw [← ofCrAnList_append] refine Submodule.mem_span.mpr fun p a => a ?_ simp only [Set.mem_setOf_eq] use φs' ++ φs simp only [ofList_append, h', h, true_and] cases f1 <;> cases f2 <;> rfl · simp [p] · intro x y hx hy hx1 hx2 simp only [add_mul, p] exact Submodule.add_mem _ hx1 hx2 · intro c a hx h1 simp only [Algebra.smul_mul_assoc, p] exact Submodule.smul_mem _ _ h1 · exact h1 · simp [p] · intro x y hx hy hx1 hx2 simp only [mul_add, p] exact Submodule.add_mem _ hx1 hx2 · intro c a hx h1 simp only [Algebra.mul_smul_comm, p] exact Submodule.smul_mem _ _ h1 decompose' a := DirectSum.of (fun i => (statSubmodule (𝓕 := 𝓕) i)) bosonic (bosonicProj a) + DirectSum.of (fun i => (statSubmodule (𝓕 := 𝓕) i)) fermionic (fermionicProj a) left_inv a := by trans a.bosonicProj + a.fermionicProj · simp · exact bosonicProj_add_fermionicProj a right_inv a := by rw [coeAddMonoidHom_apply_eq_bosonic_plus_fermionic] simp only [DFinsupp.toFun_eq_coe, map_add, bosonicProj_of_bosonic_part, bosonicProj_of_fermionic_part, add_zero, fermionicProj_of_bosonic_part, fermionicProj_of_fermionic_part, zero_add] conv_rhs => rw [directSum_eq_bosonic_plus_fermionic a] declNo: "2.30" - type: name name: FieldSpecification.FieldOpAlgebra.superCommute line: 91 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.SuperCommute status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/SuperCommute.lean#L91" isDef: true isThm: false docString: | For a field specification `𝓕`, `superCommute` is the linear map `FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕` defined as the descent of `ι ∘ superCommuteF` in both arguments. In particular for `φs` and `φs'` lists of `𝓕.CrAnFieldOp` in `FieldOpAlgebra 𝓕` the following relation holds: `superCommute φs φs' = φs * φs' - 𝓢(φs, φs') • φs' * φs` The notation `[a, b]ₛ` is used for `superCommute a b`. declString: | noncomputable def superCommute : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where toFun := Quotient.lift superCommuteRight superCommuteRight_eq_of_equiv map_add' x y := by obtain ⟨x, rfl⟩ := ι_surjective x obtain ⟨y, rfl⟩ := ι_surjective y ext b obtain ⟨b, rfl⟩ := ι_surjective b rw [← map_add, ι_apply, ι_apply, ι_apply, ι_apply] rw [Quotient.lift_mk, Quotient.lift_mk, Quotient.lift_mk] simp only [LinearMap.add_apply] rw [superCommuteRight_apply_quot, superCommuteRight_apply_quot, superCommuteRight_apply_quot] simp map_smul' c y := by obtain ⟨y, rfl⟩ := ι_surjective y ext b obtain ⟨b, rfl⟩ := ι_surjective b rw [← map_smul, ι_apply, ι_apply, ι_apply] simp only [Quotient.lift_mk, RingHom.id_apply, LinearMap.smul_apply] rw [superCommuteRight_apply_quot, superCommuteRight_apply_quot] simp declNo: "2.31" - type: h1 sectionNo: 3 content: "Time ordering" - type: name name: FieldSpecification.crAnTimeOrderRel line: 194 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/TimeOrder.lean#L194" isDef: true isThm: false docString: | 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. declString: | def crAnTimeOrderRel (a b : 𝓕.CrAnFieldOp) : Prop := 𝓕.timeOrderRel a.1 b.1 declNo: "3.1" - type: name name: FieldSpecification.crAnTimeOrderList line: 255 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/TimeOrder.lean#L255" isDef: true isThm: false docString: | For a field specification `𝓕`, and a list `φs` of `𝓕.CrAnFieldOp`, `𝓕.crAnTimeOrderList φs` is the list `φs` time-ordered using the insertion sort algorithm. declString: | def crAnTimeOrderList (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp := List.insertionSort 𝓕.crAnTimeOrderRel φs declNo: "3.2" - type: name name: FieldSpecification.crAnTimeOrderSign line: 226 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/TimeOrder.lean#L226" isDef: true isThm: false docString: | 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. declString: | def crAnTimeOrderSign (φs : List 𝓕.CrAnFieldOp) : ℂ := Wick.koszulSign 𝓕.crAnStatistics 𝓕.crAnTimeOrderRel φs declNo: "3.3" - type: name name: FieldSpecification.FieldOpFreeAlgebra.timeOrderF line: 29 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/TimeOrder.lean#L29" isDef: true isThm: false docString: | 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` declString: | def timeOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕 := Basis.constr ofCrAnListFBasis ℂ fun φs => crAnTimeOrderSign φs • ofCrAnListF (crAnTimeOrderList φs) declNo: "3.4" - type: name name: FieldSpecification.FieldOpAlgebra.timeOrder line: 370 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeOrder.lean#L370" isDef: true isThm: false docString: | For a field specification `𝓕`, `timeOrder` is the linear map `FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕` defined as the descent of `ι ∘ₗ timeOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕` from `FieldOpFreeAlgebra 𝓕` to `FieldOpAlgebra 𝓕`. This descent exists because `ι ∘ₗ timeOrderF` is well-defined on equivalence classes. The notation `𝓣(a)` is used for `timeOrder a`. declString: | noncomputable def timeOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where toFun := Quotient.lift (ι.toLinearMap ∘ₗ timeOrderF) ι_timeOrderF_eq_of_equiv map_add' x y := by obtain ⟨x, hx⟩ := ι_surjective x obtain ⟨y, hy⟩ := ι_surjective y subst hx hy rw [← map_add, ι_apply, ι_apply, ι_apply] rw [Quotient.lift_mk, Quotient.lift_mk, Quotient.lift_mk] simp map_smul' c y := by obtain ⟨y, hy⟩ := ι_surjective y subst hy rw [← map_smul, ι_apply, ι_apply] simp declNo: "3.5" - type: name name: FieldSpecification.FieldOpAlgebra.timeOrder_eq_maxTimeField_mul_finset line: 434 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeOrder.lean#L434" isDef: false isThm: false docString: | 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. declString: | lemma timeOrder_eq_maxTimeField_mul_finset (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : 𝓣(ofFieldOpList (φ :: φs)) = 𝓢(𝓕 |>ₛ maxTimeField φ φs, 𝓕 |>ₛ ⟨(eraseMaxTimeField φ φs).get, (Finset.univ.filter (fun x => (maxTimeFieldPosFin φ φs).succAbove x < maxTimeFieldPosFin φ φs))⟩) • ofFieldOp (maxTimeField φ φs) * 𝓣(ofFieldOpList (eraseMaxTimeField φ φs)) := by rw [ofFieldOpList, timeOrder_eq_ι_timeOrderF, timeOrderF_eq_maxTimeField_mul_finset] rfl declNo: "3.6" - type: name name: FieldSpecification.FieldOpAlgebra.timeOrder_timeOrder_mid line: 501 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeOrder.lean#L501" isDef: false isThm: false docString: | For a field specification `𝓕`, and `a`, `b`, `c` in `𝓕.FieldOpAlgebra`, then `𝓣(a * b * c) = 𝓣(a * 𝓣(b) * c)`. declString: | lemma timeOrder_timeOrder_mid (a b c : 𝓕.FieldOpAlgebra) : 𝓣(a * b * c) = 𝓣(a * 𝓣(b) * c) := by obtain ⟨a, rfl⟩ := ι_surjective a obtain ⟨b, rfl⟩ := ι_surjective b obtain ⟨c, rfl⟩ := ι_surjective c rw [← map_mul, ← map_mul, timeOrder_eq_ι_timeOrderF, timeOrder_eq_ι_timeOrderF, ← map_mul, ← map_mul, timeOrder_eq_ι_timeOrderF, timeOrderF_timeOrderF_mid] declNo: "3.7" - type: h1 sectionNo: 4 content: "Normal ordering" - type: name name: FieldSpecification.normalOrderRel line: 17 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.NormalOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/NormalOrder.lean#L17" isDef: true isThm: false docString: | 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. declString: | def normalOrderRel : 𝓕.CrAnFieldOp → 𝓕.CrAnFieldOp → Prop := fun a b => CreateAnnihilate.normalOrder (𝓕 |>ᶜ a) (𝓕 |>ᶜ b) declNo: "4.1" - type: name name: FieldSpecification.normalOrderList line: 225 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.NormalOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/NormalOrder.lean#L225" isDef: true isThm: false docString: | For a field specification `𝓕`, and a list `φs` of `𝓕.CrAnFieldOp`, `𝓕.normalOrderList φs` is the list `φs` normal-ordered using ther 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]` declString: | def normalOrderList (φs : List 𝓕.CrAnFieldOp) : List 𝓕.CrAnFieldOp := List.insertionSort 𝓕.normalOrderRel φs declNo: "4.2" - type: name name: FieldSpecification.normalOrderSign line: 46 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.NormalOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/NormalOrder.lean#L46" isDef: true isThm: false docString: | 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. declString: | def normalOrderSign (φs : List 𝓕.CrAnFieldOp) : ℂ := Wick.koszulSign 𝓕.crAnStatistics 𝓕.normalOrderRel φs declNo: "4.3" - type: name name: FieldSpecification.normalOrderSign_eraseIdx line: 347 fileName: PhysLean.QFT.PerturbationTheory.FieldSpecification.NormalOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldSpecification/NormalOrder.lean#L347" isDef: false isThm: false docString: | 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. declString: | lemma normalOrderSign_eraseIdx (φs : List 𝓕.CrAnFieldOp) (i : Fin φs.length) : normalOrderSign (φs.eraseIdx i) = normalOrderSign φs * 𝓢(𝓕 |>ₛ (φs.get i), 𝓕 |>ₛ (φs.take i)) * 𝓢(𝓕 |>ₛ (φs.get i), 𝓕 |>ₛ ((normalOrderList φs).take (normalOrderEquiv i))) := by rw [normalOrderSign, Wick.koszulSign_eraseIdx, ← normalOrderSign] rfl declNo: "4.4" - type: name name: FieldSpecification.FieldOpFreeAlgebra.normalOrderF line: 30 fileName: PhysLean.QFT.PerturbationTheory.FieldOpFreeAlgebra.NormalOrder status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpFreeAlgebra/NormalOrder.lean#L30" isDef: true isThm: false docString: | 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 𝓕`. declString: | def normalOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpFreeAlgebra 𝓕 := Basis.constr ofCrAnListFBasis ℂ fun φs => normalOrderSign φs • ofCrAnListF (normalOrderList φs) declNo: "4.5" - type: name name: FieldSpecification.FieldOpAlgebra.normalOrder line: 222 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/Basic.lean#L222" isDef: true isThm: false docString: | For a field specification `𝓕`, `normalOrder` is the linear map `FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕` defined as the descent of `ι ∘ₗ normalOrderF : FieldOpFreeAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕` from `FieldOpFreeAlgebra 𝓕` to `FieldOpAlgebra 𝓕`. This descent exists because `ι ∘ₗ normalOrderF` is well-defined on equivalence classes. The notation `𝓝(a)` is used for `normalOrder a` for `a` an element of `FieldOpAlgebra 𝓕`. declString: | noncomputable def normalOrder : FieldOpAlgebra 𝓕 →ₗ[ℂ] FieldOpAlgebra 𝓕 where toFun := Quotient.lift (ι.toLinearMap ∘ₗ normalOrderF) ι_normalOrderF_eq_of_equiv map_add' x y := by obtain ⟨x, rfl⟩ := ι_surjective x obtain ⟨y, rfl⟩ := ι_surjective y rw [← map_add, ι_apply, ι_apply, ι_apply] rw [Quotient.lift_mk, Quotient.lift_mk, Quotient.lift_mk] simp map_smul' c y := by obtain ⟨y, rfl⟩ := ι_surjective y rw [← map_smul, ι_apply, ι_apply] simp declNo: "4.6" - type: name name: FieldSpecification.FieldOpAlgebra.normalOrder_superCommute_eq_zero line: 121 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.Lemmas status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/Lemmas.lean#L121" isDef: false isThm: false docString: | For a field specification `𝓕`, and `a` and `b` in `𝓕.FieldOpAlgebra` the normal ordering of the super commutator of `a` and `b` vanishes, i.e. `𝓝([a,b]ₛ) = 0`. declString: | lemma normalOrder_superCommute_eq_zero (a b : 𝓕.FieldOpAlgebra) : 𝓝([a, b]ₛ) = 0 := by obtain ⟨a, rfl⟩ := ι_surjective a obtain ⟨b, rfl⟩ := ι_surjective b rw [superCommute_eq_ι_superCommuteF, normalOrder_eq_ι_normalOrderF] simp declNo: "4.7" - type: name name: FieldSpecification.FieldOpAlgebra.ofCrAnOp_superCommute_normalOrder_ofCrAnList_sum line: 221 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.Lemmas status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/Lemmas.lean#L221" isDef: false isThm: false docString: | 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 `𝓕.FieldOpAlgebra` is used to rearrange terms. - Properties of ordered lists, and `normalOrderSign_eraseIdx` are then used to complete the proof. declString: | lemma ofCrAnOp_superCommute_normalOrder_ofCrAnList_sum (φ : 𝓕.CrAnFieldOp) (φs : List 𝓕.CrAnFieldOp) : [ofCrAnOp φ, 𝓝(ofCrAnList φs)]ₛ = ∑ n : Fin φs.length, 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ (φs.take n)) • [ofCrAnOp φ, ofCrAnOp φs[n]]ₛ * 𝓝(ofCrAnList (φs.eraseIdx n)) := by rw [normalOrder_ofCrAnList, map_smul] rw [superCommute_ofCrAnOp_ofCrAnList_eq_sum, Finset.smul_sum, sum_normalOrderList_length] congr funext n simp only [instCommGroup.eq_1, List.get_eq_getElem, normalOrderList_get_normalOrderEquiv, normalOrderList_eraseIdx_normalOrderEquiv, Algebra.smul_mul_assoc, Fin.getElem_fin] rw [ofCrAnList_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 declNo: "4.8" - type: name name: FieldSpecification.FieldOpAlgebra.ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum line: 347 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.Lemmas status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/Lemmas.lean#L347" isDef: false isThm: false docString: | 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. declString: | lemma ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) : ofFieldOp φ * 𝓝(ofFieldOpList φs) = ∑ n : Option (Fin φs.length), contractStateAtIndex φ φs n * 𝓝(ofFieldOpList (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 declNo: "4.9" - type: h1 sectionNo: 5 content: "Wick Contractions" - type: h2 sectionNo: "5.1" content: "Definition" - type: name name: WickContraction line: 16 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Basic.lean#L16" isDef: true isThm: false docString: | 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. declString: | def WickContraction (n : ℕ) : Type := {f : Finset ((Finset (Fin n))) // (∀ a ∈ f, a.card = 2) ∧ (∀ a ∈ f, ∀ b ∈ f, a = b ∨ Disjoint a b)} declNo: "5.1" - type: name name: WickContraction.mem_three line: 110 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.ExtractEquiv status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/ExtractEquiv.lean#L110" isDef: false isThm: false docString: | 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`. declString: | lemma mem_three (c : WickContraction 3) : c.1 ∈ ({∅, {{0, 1}}, {{0, 2}}, {{1, 2}}} : Finset (Finset (Finset (Fin 3)))) := by fin_cases c <;> simp only [Fin.isValue, Nat.succ_eq_add_one, Nat.reduceAdd, Function.Embedding.coeFn_mk, Finset.mem_insert, Finset.mem_singleton] · exact Or.inl rfl · exact Or.inr (Or.inl rfl) · exact Or.inr (Or.inr (Or.inl rfl)) · exact Or.inr (Or.inr (Or.inr rfl)) declNo: "5.2" - type: name name: WickContraction.mem_four line: 129 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.ExtractEquiv status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/ExtractEquiv.lean#L129" isDef: false isThm: false docString: | 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`. declString: | lemma mem_four (c : WickContraction 4) : c.1 ∈ ({∅, {{0, 1}}, {{0, 2}}, {{0, 3}}, {{1, 2}}, {{1, 3}}, {{2,3}}, {{0, 1}, {2, 3}}, {{0, 2}, {1, 3}}, {{0, 3}, {1, 2}}} : Finset (Finset (Finset (Fin 4)))) := by fin_cases c <;> simp only [Fin.isValue, Nat.succ_eq_add_one, Nat.reduceAdd, Function.Embedding.coeFn_mk, Finset.mem_insert, Finset.mem_singleton] · exact Or.inl rfl -- ∅ · exact Or.inr (Or.inl rfl) -- {{0, 1}} · exact Or.inr (Or.inr (Or.inl rfl)) -- {{0, 2}} · exact Or.inr (Or.inr (Or.inr (Or.inl rfl))) -- {{0, 3}} · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inl rfl)))) -- {{1, 2}} · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr rfl)))))))) · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl rfl))))) -- {{1, 3}} · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl rfl)))))))) · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl rfl)))))) -- {{2, 3 }} · exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inr (Or.inl rfl))))))) declNo: "5.3" - type: remark name: "contraction_notation" status : "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Basic.lean#L31" content: | Given a field specification `𝓕`, and a list `φs` of `𝓕.FieldOp`, a Wick contraction of `φs` will mean a Wick contraction in `WickContraction φs.length`. The notation `φsΛ` will be used for such contractions. The terminology that `φsΛ` contracts pairs within of `φs` will also be used, even though `φsΛ` is really contains positions of `φs`. - type: name name: WickContraction.GradingCompliant line: 520 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Basic.lean#L520" isDef: true isThm: false docString: | 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. declString: | def GradingCompliant (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) := ∀ (a : φsΛ.1), (𝓕 |>ₛ φs[φsΛ.fstFieldOfContract a]) = (𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a]) declNo: "5.4" - type: h2 sectionNo: "5.2" content: "Aside: Cardinality" - type: name name: WickContraction.card_eq_cardFun line: 240 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Card status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Card.lean#L240" isDef: false isThm: true docString: | 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, ... declString: | theorem card_eq_cardFun : (n : ℕ) → Fintype.card (WickContraction n) = cardFun n | 0 => by decide | 1 => by decide | Nat.succ (Nat.succ n) => by rw [wickContraction_card_eq_sum_zero_none_isSome, wickContraction_zero_none_card, wickContraction_zero_some_eq_mul] simp only [cardFun, succ_eq_add_one] rw [← card_eq_cardFun n, ← card_eq_cardFun (n + 1)] declNo: "5.5" - type: h2 sectionNo: "5.3" content: "Uncontracted elements" - type: name name: WickContraction.uncontracted line: 19 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Uncontracted status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Uncontracted.lean#L19" isDef: true isThm: false docString: | For a Wick contraction `c`, `c.uncontracted` is defined as the finset of elements of `Fin n` which are not in any contracted pair. declString: | def uncontracted : Finset (Fin n) := Finset.filter (fun i => c.getDual? i = none) (Finset.univ) declNo: "5.6" - type: name name: WickContraction.uncontractedListGet line: 317 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.UncontractedList status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/UncontractedList.lean#L317" isDef: true isThm: false docString: | 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`. declString: | def uncontractedListGet {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : List 𝓕.FieldOp := φsΛ.uncontractedList.map φs.get declNo: "5.7" - type: h2 sectionNo: "5.4" content: "Constructors" - type: name name: WickContraction.insertAndContract line: 27 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.InsertAndContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/InsertAndContract.lean#L27" isDef: true isThm: false docString: | 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`. declString: | def insertAndContract {φs : List 𝓕.FieldOp} (φ : 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : Option φsΛ.uncontracted) : WickContraction (φs.insertIdx i φ).length := congr (by simp) (φsΛ.insertAndContractNat i k) declNo: "5.8" - type: name name: WickContraction.insertLift_sum line: 290 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.InsertAndContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/InsertAndContract.lean#L290" isDef: false isThm: false docString: | 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`. declString: | lemma insertLift_sum (φ : 𝓕.FieldOp) {φs : List 𝓕.FieldOp} (i : Fin φs.length.succ) [AddCommMonoid M] (f : WickContraction (φs.insertIdx i φ).length → M) : ∑ c, f c = ∑ (φsΛ : WickContraction φs.length), ∑ (k : Option φsΛ.uncontracted), f (φsΛ ↩Λ φ i k) := by rw [sum_extractEquiv_congr (finCongr (insertIdx_length_fin φ φs i).symm i) f (insertIdx_length_fin φ φs i)] rfl declNo: "5.9" - type: name name: WickContraction.join line: 26 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Join status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Join.lean#L26" isDef: true isThm: false docString: | 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`. declString: | def join {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) : WickContraction φs.length := ⟨φsΛ.1 ∪ φsucΛ.1.map (Finset.mapEmbedding uncontractedListEmd).toEmbedding, by intro a ha simp only [Finset.le_eq_subset, Finset.mem_union, Finset.mem_map, RelEmbedding.coe_toEmbedding] at ha rcases ha with ha | ha · exact φsΛ.2.1 a ha · obtain ⟨a, ha, rfl⟩ := ha rw [Finset.mapEmbedding_apply] simp only [Finset.card_map] exact φsucΛ.2.1 a ha, by intro a ha b hb simp only [Finset.le_eq_subset, Finset.mem_union, Finset.mem_map, RelEmbedding.coe_toEmbedding] at ha hb rcases ha with ha | ha <;> rcases hb with hb | hb · exact φsΛ.2.2 a ha b hb · obtain ⟨b, hb, rfl⟩ := hb right symm rw [Finset.mapEmbedding_apply] apply uncontractedListEmd_finset_disjoint_left exact ha · obtain ⟨a, ha, rfl⟩ := ha right rw [Finset.mapEmbedding_apply] apply uncontractedListEmd_finset_disjoint_left exact hb · obtain ⟨a, ha, rfl⟩ := ha obtain ⟨b, hb, rfl⟩ := hb simp only [EmbeddingLike.apply_eq_iff_eq] rw [Finset.mapEmbedding_apply, Finset.mapEmbedding_apply] rw [Finset.disjoint_map] exact φsucΛ.2.2 a ha b hb⟩ declNo: "5.10" - type: h2 sectionNo: "5.5" content: "Sign" - type: name name: WickContraction.sign line: 32 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.Basic status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/Basic.lean#L32" isDef: true isThm: false docString: | 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` declString: | def sign (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : ℂ := ∏ (a : φsΛ.1), 𝓢(𝓕 |>ₛ φs[φsΛ.sndFieldOfContract a], 𝓕 |>ₛ ⟨φs.get, φsΛ.signFinset (φsΛ.fstFieldOfContract a) (φsΛ.sndFieldOfContract a)⟩) declNo: "5.11" - type: name name: WickContraction.join_sign line: 420 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.Join status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/Join.lean#L420" isDef: false isThm: false docString: | 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. declString: | lemma join_sign {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) (hc : φsΛ.GradingCompliant) : (join φsΛ φsucΛ).sign = φsΛ.sign * φsucΛ.sign := join_sign_induction φsΛ φsucΛ hc (φsΛ).1.card rfl declNo: "5.12" - type: name name: WickContraction.sign_insert_none line: 241 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.InsertNone status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/InsertNone.lean#L241" isDef: false isThm: false docString: | 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 `FieldOp`s in `φs` to the sign of `φsΛ ↩Λ φ i none`. declString: | lemma sign_insert_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (hG : GradingCompliant φs φsΛ) : (φsΛ ↩Λ φ i none).sign = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => (φsΛ.getDual? x).isSome ∧ i.succAbove x < i)⟩) * φsΛ.sign := by rw [sign_insert_none_eq_signInsertNone_mul_sign] rw [signInsertNone_eq_filterset] exact hG declNo: "5.13" - type: name name: WickContraction.sign_insert_none_zero line: 257 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.InsertNone status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/InsertNone.lean#L257" isDef: false isThm: false docString: | For a list `φs = φ₀…φₙ` of `𝓕.FieldOp`, a graded compliant Wick contraction `φsΛ` of `φs`, and a `φ` in `𝓕.FieldOp`, then `(φsΛ ↩Λ φ 0 none).sign = φsΛ.sign`. This is a direct corollary of `sign_insert_none`. declString: | lemma sign_insert_none_zero (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : (φsΛ ↩Λ φ 0 none).sign = φsΛ.sign := by rw [sign_insert_none_eq_signInsertNone_mul_sign] simp [signInsertNone] declNo: "5.14" - type: name name: WickContraction.sign_insert_some_of_not_lt line: 882 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.InsertSome status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/InsertSome.lean#L882" isDef: false isThm: false docString: | 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)`. declString: | lemma sign_insert_some_of_not_lt (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted) (hk : ¬ i.succAbove k < i) (hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = 𝓕 |>ₛ φs[k.1]) : (φsΛ ↩Λ φ i (some k)).sign = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => x < ↑k)⟩) * 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => i.succAbove x < i)⟩) * φsΛ.sign := by rw [sign_insert_some, ← signInsertSome_mul_filter_contracted_of_not_lt φ φs φsΛ i k hk hg] rw [← mul_assoc] congr 1 rw [mul_comm, ← mul_assoc] simp declNo: "5.15" - type: name name: WickContraction.sign_insert_some_of_lt line: 857 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.InsertSome status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/InsertSome.lean#L857" isDef: false isThm: false docString: | 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ₛ φ) = 𝓕 |>ₛ φs[k.1]) : (φsΛ ↩Λ φ i (some k)).sign = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => x ≤ ↑k)⟩) * 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, Finset.univ.filter (fun x => i.succAbove x < i)⟩) * φsΛ.sign := by rw [sign_insert_some, ← signInsertSome_mul_filter_contracted_of_lt φ φs φsΛ i k hk hg] rw [← mul_assoc] congr 1 rw [mul_comm, ← mul_assoc] simp declNo: "5.16" - type: name name: WickContraction.sign_insert_some_zero line: 907 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.InsertSome status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/InsertSome.lean#L907" isDef: false isThm: false docString: | 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`. declString: | lemma sign_insert_some_zero (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) (hn : GradingCompliant φs φsΛ ∧ (𝓕|>ₛφ) = 𝓕|>ₛφs[k.1]) : (φsΛ ↩Λ φ 0 k).sign = 𝓢(𝓕|>ₛφ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < ↑k))⟩) * φsΛ.sign := by rw [sign_insert_some_of_not_lt] · simp · simp · exact hn declNo: "5.17" - type: h2 sectionNo: "5.6" content: "Normal order" - type: name name: FieldSpecification.FieldOpAlgebra.normalOrder_uncontracted_none line: 28 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.WickContractions status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/WickContractions.lean#L28" isDef: false isThm: false docString: | 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`. declString: | lemma normalOrder_uncontracted_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : 𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ) = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, φsΛ.uncontracted.filter (fun x => i.succAbove x < i)⟩) • 𝓝(ofFieldOpList (φ :: [φsΛ]ᵘᶜ)) := by simp only [Nat.succ_eq_add_one, instCommGroup.eq_1] rw [ofFieldOpList_normalOrder_insert φ [φsΛ]ᵘᶜ ⟨(φsΛ.uncontractedListOrderPos i), by simp [uncontractedListGet]⟩, smul_smul] trans (1 : ℂ) • (𝓝(ofFieldOpList [φsΛ ↩Λ φ i none]ᵘᶜ)) · simp congr 1 simp only [instCommGroup.eq_1, uncontractedListGet] rw [← List.map_take, take_uncontractedListOrderPos_eq_filter] have h1 : (𝓕 |>ₛ List.map φs.get (List.filter (fun x => decide (↑x < i.1)) φsΛ.uncontractedList)) = 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x.val < i.1))⟩ := by simp only [Nat.succ_eq_add_one, ofFinset] congr rw [uncontractedList_eq_sort] have hdup : (List.filter (fun x => decide (x.1 < i.1)) (Finset.sort (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)).Nodup := by exact List.Nodup.filter _ (Finset.sort_nodup (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted) have hsort : (List.filter (fun x => decide (x.1 < i.1)) (Finset.sort (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted)).Sorted (· ≤ ·) := by exact List.Sorted.filter _ (Finset.sort_sorted (fun x1 x2 => x1 ≤ x2) φsΛ.uncontracted) rw [← (List.toFinset_sort (· ≤ ·) hdup).mpr hsort] congr ext a simp rw [h1] simp only [Nat.succ_eq_add_one] have h2 : (Finset.filter (fun x => x.1 < i.1) φsΛ.uncontracted) = (Finset.filter (fun x => i.succAbove x < i) φsΛ.uncontracted) := by ext a simp only [Nat.succ_eq_add_one, Finset.mem_filter, and_congr_right_iff] intro ha simp only [Fin.succAbove] split · apply Iff.intro · intro h omega · intro h rename_i h rw [Fin.lt_def] at h simp only [Fin.coe_castSucc] at h omega · apply Iff.intro · intro h rename_i h' rw [Fin.lt_def] simp only [Fin.val_succ] rw [Fin.lt_def] at h' simp only [Fin.coe_castSucc, not_lt] at h' omega · intro h rename_i h rw [Fin.lt_def] at h simp only [Fin.val_succ] at h omega rw [h2] simp only [exchangeSign_mul_self] congr simp only [Nat.succ_eq_add_one] rw [insertAndContract_uncontractedList_none_map] declNo: "5.18" - type: name name: FieldSpecification.FieldOpAlgebra.normalOrder_uncontracted_some line: 101 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.NormalOrder.WickContractions status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/NormalOrder/WickContractions.lean#L101" isDef: false isThm: false docString: | 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. declString: | lemma normalOrder_uncontracted_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) : 𝓝(ofFieldOpList [φsΛ ↩Λ φ i (some k)]ᵘᶜ) = 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ ((uncontractedFieldOpEquiv φs φsΛ) k))) := by simp only [Nat.succ_eq_add_one, insertAndContract, optionEraseZ, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast, uncontractedListGet] congr rw [congr_uncontractedList] erw [uncontractedList_extractEquiv_symm_some] simp only [Fin.coe_succAboveEmb, List.map_eraseIdx, List.map_map] congr conv_rhs => rw [get_eq_insertIdx_succAbove φ φs i] declNo: "5.19" - type: h1 sectionNo: 6 content: "Static Wick's theorem" - type: h2 sectionNo: "6.1" content: "Static contractions" - type: name name: WickContraction.staticContract line: 22 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.StaticContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/StaticContract.lean#L22" isDef: true isThm: false docString: | For a list `φs` of `𝓕.FieldOp` and a Wick contraction `φsΛ`, the element of the center of `𝓕.FieldOpAlgebra`, `φsΛ.staticContract` is defined as the product of `[anPart φs[j], φs[k]]ₛ` over contracted pairs `{j, k}` in `φsΛ` with `j < k`. declString: | noncomputable def staticContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : Subalgebra.center ℂ 𝓕.FieldOpAlgebra := ∏ (a : φsΛ.1), ⟨[anPart (φs.get (φsΛ.fstFieldOfContract a)), ofFieldOp (φs.get (φsΛ.sndFieldOfContract a))]ₛ, superCommute_anPart_ofFieldOp_mem_center _ _⟩ declNo: "6.1" - type: name name: WickContraction.staticContract_insert_none line: 33 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.StaticContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/StaticContract.lean#L33" isDef: false isThm: false docString: | 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).staticContract = φsΛ.staticContract` The proof of this result ultimately is a consequence of definitions. declString: | lemma staticContract_insert_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (φsΛ ↩Λ φ i none).staticContract = φsΛ.staticContract := by rw [staticContract, insertAndContract_none_prod_contractions] congr ext a simp declNo: "6.2" - type: name name: WickContraction.staticContract_insert_some line: 49 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.StaticContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/StaticContract.lean#L49" isDef: false isThm: false docString: | 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. declString: | lemma staticContract_insert_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (j : φsΛ.uncontracted) : (φsΛ ↩Λ φ i (some j)).staticContract = (if i < i.succAbove j then ⟨[anPart φ, ofFieldOp φs[j.1]]ₛ, superCommute_anPart_ofFieldOp_mem_center _ _⟩ else ⟨[anPart φs[j.1], ofFieldOp φ]ₛ, superCommute_anPart_ofFieldOp_mem_center _ _⟩) * φsΛ.staticContract := by rw [staticContract, insertAndContract_some_prod_contractions] congr 1 · simp only [Nat.succ_eq_add_one, insertAndContract_fstFieldOfContract_some_incl, finCongr_apply, List.get_eq_getElem, insertAndContract_sndFieldOfContract_some_incl, Fin.getElem_fin] split · simp · simp · congr ext a simp declNo: "6.3" - type: h2 sectionNo: "6.2" content: "Static Wick terms" - type: name name: WickContraction.staticWickTerm line: 25 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTerm.lean#L25" isDef: true isThm: false docString: | For a list `φs` of `𝓕.FieldOp`, and a Wick contraction `φsΛ` of `φs`, the element of `𝓕.FieldOpAlgebra`, `φsΛ.staticWickTerm` is defined as `φsΛ.sign • φsΛ.staticContract * 𝓝([φsΛ]ᵘᶜ)`. This is a term which appears in the static version Wick's theorem. declString: | def staticWickTerm {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.FieldOpAlgebra := φsΛ.sign • φsΛ.staticContract * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ) declNo: "6.4" - type: name name: WickContraction.staticWickTerm_empty_nil line: 34 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTerm.lean#L34" isDef: false isThm: false docString: | For the empty list `[]` of `𝓕.FieldOp`, the `staticWickTerm` of the Wick contraction corresponding to the empty set `∅` (the only Wick contraction of `[]`) is `1`. declString: | lemma staticWickTerm_empty_nil : staticWickTerm (empty (n := ([] : List 𝓕.FieldOp).length)) = 1 := by rw [staticWickTerm, uncontractedListGet, nil_zero_uncontractedList] simp [sign, empty, staticContract] declNo: "6.5" - type: name name: WickContraction.staticWickTerm_insert_zero_none line: 42 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTerm.lean#L42" isDef: false isThm: false docString: | 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. declString: | lemma staticWickTerm_insert_zero_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : (φsΛ ↩Λ φ 0 none).staticWickTerm = φsΛ.sign • φsΛ.staticContract * 𝓝(ofFieldOpList (φ :: [φsΛ]ᵘᶜ)) := by symm erw [staticWickTerm, sign_insert_none_zero] simp only [staticContract_insert_none, insertAndContract_uncontractedList_none_zero, Algebra.smul_mul_assoc] declNo: "6.6" - type: name name: WickContraction.staticWickTerm_insert_zero_some line: 61 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTerm.lean#L61" isDef: false isThm: false docString: | 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. declString: | lemma staticWickTerm_insert_zero_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (k : { x // x ∈ φsΛ.uncontracted }) : (φsΛ ↩Λ φ 0 k).staticWickTerm = sign φs φsΛ • (↑φsΛ.staticContract * (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) * 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedFieldOpEquiv φs φsΛ k))))) := by symm rw [staticWickTerm, normalOrder_uncontracted_some] simp only [← mul_assoc] rw [← smul_mul_assoc] congr 1 rw [staticContract_insert_some_of_lt] swap · simp rw [smul_smul] by_cases hn : GradingCompliant φs φsΛ ∧ (𝓕|>ₛφ) = (𝓕|>ₛ φs[k.1]) · congr 1 swap · rw [Subalgebra.mem_center_iff.mp φsΛ.staticContract.2] · rw [sign_insert_some_zero _ _ _ _ hn, mul_comm, ← mul_assoc] simp · simp only [Fin.getElem_fin, not_and] at hn by_cases h0 : ¬ GradingCompliant φs φsΛ · rw [staticContract_of_not_gradingCompliant] simp only [ZeroMemClass.coe_zero, zero_mul, smul_zero, instCommGroup.eq_1, mul_zero] exact h0 · simp_all only [Finset.mem_univ, not_not, instCommGroup.eq_1, forall_const] have h1 : contractStateAtIndex φ [φsΛ]ᵘᶜ (uncontractedFieldOpEquiv φs φsΛ k) = 0 := by simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, instCommGroup.eq_1, Fin.coe_cast, Fin.getElem_fin, smul_eq_zero] right simp only [uncontractedListGet, List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem] rw [superCommute_anPart_ofFieldOpF_diff_grade_zero] exact hn rw [h1] simp declNo: "6.7" - type: name name: WickContraction.mul_staticWickTerm_eq_sum line: 115 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTerm.lean#L115" isDef: false isThm: false docString: | 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. declString: | lemma mul_staticWickTerm_eq_sum (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) : ofFieldOp φ * φsΛ.staticWickTerm = ∑ (k : Option φsΛ.uncontracted), (φsΛ ↩Λ φ 0 k).staticWickTerm := by trans (φsΛ.sign • φsΛ.staticContract * (ofFieldOp φ * normalOrder (ofFieldOpList [φsΛ]ᵘᶜ))) · have ht := Subalgebra.mem_center_iff.mp (Subalgebra.smul_mem (Subalgebra.center ℂ _) (φsΛ.staticContract).2 φsΛ.sign) conv_rhs => rw [← mul_assoc, ← ht] simp [mul_assoc, staticWickTerm] rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum] rw [Finset.mul_sum] rw [uncontractedFieldOpEquiv_list_sum] refine Finset.sum_congr rfl (fun n _ => ?_) match n with | none => simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_none', one_mul, Algebra.smul_mul_assoc, Nat.succ_eq_add_one, Fin.zero_eta, Fin.val_zero, List.insertIdx_zero, staticContract_insert_none, insertAndContract_uncontractedList_none_zero] rw [staticWickTerm_insert_zero_none] simp only [Algebra.smul_mul_assoc] rfl | some n => simp only [Algebra.smul_mul_assoc, Nat.succ_eq_add_one, Fin.zero_eta, Fin.val_zero, List.insertIdx_zero] rw [staticWickTerm_insert_zero_some] declNo: "6.8" - type: h2 sectionNo: "6.3" content: "The Static Wick's theorem" - type: name name: FieldSpecification.FieldOpAlgebra.static_wick_theorem line: 22 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.StaticWickTheorem status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/StaticWickTheorem.lean#L22" isDef: false isThm: true docString: | 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: 1. The proof considers `φ₀…φₙ` as `φ₀(φ₁…φₙ)` and uses the induction hypothesis on `φ₁…φₙ`. 2. 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: 1. 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. declString: | theorem static_wick_theorem : (φs : List 𝓕.FieldOp) → ofFieldOpList φs = ∑ (φsΛ : WickContraction φs.length), φsΛ.staticWickTerm | [] => by simp only [ofFieldOpList, ofFieldOpListF_nil, map_one, List.length_nil] rw [sum_WickContraction_nil] rw [staticWickTerm_empty_nil] | φ :: φs => by rw [ofFieldOpList_cons, static_wick_theorem φs] rw [show (φ :: φs) = φs.insertIdx (⟨0, Nat.zero_lt_succ φs.length⟩ : Fin φs.length.succ) φ from rfl] conv_rhs => rw [insertLift_sum] rw [Finset.mul_sum] apply Finset.sum_congr rfl intro c _ rw [mul_staticWickTerm_eq_sum] rfl declNo: "6.9" - type: h1 sectionNo: 7 content: "Wick's theorem" - type: h2 sectionNo: "7.1" content: "Time contractions" - type: name name: FieldSpecification.FieldOpAlgebra.timeContract line: 26 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeContraction status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeContraction.lean#L26" isDef: true isThm: false docString: | For a field specification `𝓕`, and `φ` and `ψ` elements of `𝓕.FieldOp`, the element of `𝓕.FieldOpAlgebra`, `timeContract φ ψ` is defined to be `𝓣(φψ) - 𝓝(φψ)`. declString: | def timeContract (φ ψ : 𝓕.FieldOp) : 𝓕.FieldOpAlgebra := 𝓣(ofFieldOp φ * ofFieldOp ψ) - 𝓝(ofFieldOp φ * ofFieldOp ψ) declNo: "7.1" - type: name name: FieldSpecification.FieldOpAlgebra.timeContract_of_timeOrderRel line: 34 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeContraction status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeContraction.lean#L34" isDef: false isThm: false docString: | For a field specification `𝓕`, and `φ` and `ψ` elements of `𝓕.FieldOp`, if `φ` and `ψ` are time-ordered then `timeContract φ ψ = [anPart φ, ofFieldOp ψ]ₛ`. declString: | lemma timeContract_of_timeOrderRel (φ ψ : 𝓕.FieldOp) (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 declNo: "7.2" - type: name name: FieldSpecification.FieldOpAlgebra.timeContract_of_not_timeOrderRel_expand line: 61 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeContraction status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeContraction.lean#L61" isDef: false isThm: false docString: | For a field specification `𝓕`, and `φ` and `ψ` elements of `𝓕.FieldOp`, if `φ` and `ψ` are not time-ordered then `timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • [anPart ψ, ofFieldOp φ]ₛ`. declString: | lemma timeContract_of_not_timeOrderRel_expand (φ ψ : 𝓕.FieldOp) (h : ¬ timeOrderRel φ ψ) : timeContract φ ψ = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ψ) • [anPart ψ, ofFieldOp φ]ₛ := by rw [timeContract_of_not_timeOrderRel _ _ h] rw [timeContract_of_timeOrderRel _ _ _] have h1 := IsTotal.total (r := 𝓕.timeOrderRel) φ ψ simp_all declNo: "7.3" - type: name name: FieldSpecification.FieldOpAlgebra.timeContract_mem_center line: 72 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.TimeContraction status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/TimeContraction.lean#L72" isDef: false isThm: false docString: | For a field specification `𝓕`, and `φ` and `ψ` elements of `𝓕.FieldOp`, then `timeContract φ ψ` is in the center of `𝓕.FieldOpAlgebra`. declString: | lemma timeContract_mem_center (φ ψ : 𝓕.FieldOp) : 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 declNo: "7.4" - type: name name: WickContraction.timeContract line: 22 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeContract.lean#L22" isDef: true isThm: false docString: | For a list `φs` of `𝓕.FieldOp` and a Wick contraction `φsΛ` the element of the center of `𝓕.FieldOpAlgebra`, `φsΛ.timeContract` is defined as the product of `timeContract φs[j] φs[k]` over contracted pairs `{j, k}` in `φsΛ` with `j < k`. declString: | noncomputable def timeContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : Subalgebra.center ℂ 𝓕.FieldOpAlgebra := ∏ (a : φsΛ.1), ⟨FieldOpAlgebra.timeContract (φs.get (φsΛ.fstFieldOfContract a)) (φs.get (φsΛ.sndFieldOfContract a)), timeContract_mem_center _ _⟩ declNo: "7.5" - type: name name: WickContraction.timeContract_insert_none line: 33 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeContract.lean#L33" isDef: false isThm: false docString: | For a list `φs = φ₀…φₙ` of `𝓕.FieldOp`, a Wick contraction `φsΛ` of `φs`, an element `φ` of `𝓕.FieldOp`, and a `i ≤ φs.length` the following relation holds `(φsΛ ↩Λ φ i none).timeContract = φsΛ.timeContract` The proof of this result ultimately is a consequence of definitions. declString: | lemma timeContract_insert_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) : (φsΛ ↩Λ φ i none).timeContract = φsΛ.timeContract := by rw [timeContract, insertAndContract_none_prod_contractions] congr ext a simp declNo: "7.6" - type: name name: WickContraction.timeContract_insert_some_of_not_lt line: 126 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeContract.lean#L126" isDef: false isThm: false docString: | 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`. declString: | lemma timeContract_insert_some_of_not_lt (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted) (ht : ¬ 𝓕.timeOrderRel φs[k.1] φ) (hik : ¬ i < i.succAbove k) : (φsΛ ↩Λ φ i (some k)).timeContract = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x ≤ k))⟩) • (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) * φsΛ.timeContract) := by rw [timeContract_insertAndContract_some] simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1, contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast, List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem, Algebra.smul_mul_assoc, uncontractedListGet] simp only [hik, ↓reduceIte, MulMemClass.coe_mul] rw [timeContract_of_not_timeOrderRel, timeContract_of_timeOrderRel] simp only [instCommGroup.eq_1, Algebra.smul_mul_assoc, smul_smul] congr have h1 : ofList 𝓕.fieldOpStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k)) (List.map φs.get φsΛ.uncontractedList)) = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) φsΛ.uncontracted)⟩) := by simp only [ofFinset] congr rw [← List.map_take] congr rw [take_uncontractedIndexEquiv_symm, filter_uncontractedList] rw [h1] trans 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, {k.1}⟩) · rw [exchangeSign_symm, ofFinset_singleton] simp rw [← map_mul] congr rw [ofFinset_union] congr ext a simp only [Finset.mem_singleton, Finset.mem_sdiff, Finset.mem_union, Finset.mem_filter, Finset.mem_inter, not_and, not_lt, and_imp] apply Iff.intro · intro h subst h simp · intro h have h1 := h.1 rcases h1 with h1 | h1 · have h2' := h.2 h1.1 h1.2 h1.1 omega · have h2' := h.2 h1.1 (by omega) h1.1 omega have ht := IsTotal.total (r := timeOrderRel) φs[k.1] φ simp_all only [Fin.getElem_fin, Nat.succ_eq_add_one, not_lt, false_or] exact ht declNo: "7.7" - type: name name: WickContraction.timeContract_insert_some_of_lt line: 82 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeContract status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeContract.lean#L82" isDef: false isThm: false docString: | 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`. declString: | lemma timeContract_insert_some_of_lt (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (φsΛ : WickContraction φs.length) (i : Fin φs.length.succ) (k : φsΛ.uncontracted) (ht : 𝓕.timeOrderRel φ φs[k.1]) (hik : i < i.succAbove k) : (φsΛ ↩Λ φ i (some k)).timeContract = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (φsΛ.uncontracted.filter (fun x => x < k))⟩) • (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) * φsΛ.timeContract) := by rw [timeContract_insertAndContract_some] simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, instCommGroup.eq_1, contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast, List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem, Algebra.smul_mul_assoc, uncontractedListGet] · simp only [hik, ↓reduceIte, MulMemClass.coe_mul] rw [timeContract_of_timeOrderRel] trans (1 : ℂ) • ((superCommute (anPart φ)) (ofFieldOp φs[k.1]) * ↑φsΛ.timeContract) · simp simp only [smul_smul] congr 1 have h1 : ofList 𝓕.fieldOpStatistic (List.take (↑(φsΛ.uncontractedIndexEquiv.symm k)) (List.map φs.get φsΛ.uncontractedList)) = (𝓕 |>ₛ ⟨φs.get, (Finset.filter (fun x => x < k) φsΛ.uncontracted)⟩) := by simp only [ofFinset] congr rw [← List.map_take] congr rw [take_uncontractedIndexEquiv_symm] rw [filter_uncontractedList] rw [h1] simp only [exchangeSign_mul_self] · exact ht declNo: "7.8" - type: name name: WickContraction.join_sign_timeContract line: 432 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.Sign.Join status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/Sign/Join.lean#L432" isDef: false isThm: false docString: | 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`. declString: | lemma join_sign_timeContract {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (φsucΛ : WickContraction [φsΛ]ᵘᶜ.length) : (join φsΛ φsucΛ).sign • (join φsΛ φsucΛ).timeContract.1 = (φsΛ.sign • φsΛ.timeContract.1) * (φsucΛ.sign • φsucΛ.timeContract.1) := by rw [join_timeContract] by_cases h : φsΛ.GradingCompliant · rw [join_sign _ _ h] simp [smul_smul, mul_comm] · rw [timeContract_of_not_gradingCompliant _ _ h] simp declNo: "7.9" - type: h2 sectionNo: "7.2" content: "Wick terms" - type: name name: WickContraction.wickTerm line: 27 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WickTerm.lean#L27" isDef: true isThm: false docString: | For a list `φs` of `𝓕.FieldOp`, and a Wick contraction `φsΛ` of `φs`, the element of `𝓕.FieldOpAlgebra`, `φsΛ.wickTerm` is defined as `φsΛ.sign • φsΛ.timeContract * 𝓝([φsΛ]ᵘᶜ)`. This is a term which appears in the Wick's theorem. declString: | def wickTerm {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) : 𝓕.FieldOpAlgebra := φsΛ.sign • φsΛ.timeContract * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ) declNo: "7.10" - type: name name: WickContraction.wickTerm_empty_nil line: 36 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WickTerm.lean#L36" isDef: false isThm: false docString: | For the empty list `[]` of `𝓕.FieldOp`, the `wickTerm` of the Wick contraction corresponding to the empty set `∅` (the only Wick contraction of `[]`) is `1`. declString: | lemma wickTerm_empty_nil : wickTerm (empty (n := ([] : List 𝓕.FieldOp).length)) = 1 := by rw [wickTerm] simp [sign_empty] declNo: "7.11" - type: name name: WickContraction.wickTerm_insert_none line: 44 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WickTerm.lean#L44" isDef: false isThm: false docString: | 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. declString: | lemma wickTerm_insert_none (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) : (φsΛ ↩Λ φ i none).wickTerm = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun k => i.succAbove k < i))⟩) • (φsΛ.sign • φsΛ.timeContract * 𝓝(ofFieldOpList (φ :: [φsΛ]ᵘᶜ))) := by rw [wickTerm] by_cases hg : GradingCompliant φs φsΛ · rw [normalOrder_uncontracted_none, sign_insert_none _ _ _ _ hg] simp only [Nat.succ_eq_add_one, timeContract_insert_none, instCommGroup.eq_1, Algebra.mul_smul_comm, Algebra.smul_mul_assoc, smul_smul] congr 1 rw [← mul_assoc] congr 1 rw [← map_mul] congr rw [ofFinset_union] congr ext a simp only [Finset.mem_sdiff, Finset.mem_union, Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_inter, not_and, not_lt, and_imp] apply Iff.intro · intro ha have ha1 := ha.1 rcases ha1 with ha1 | ha1 · exact ha1.2 · exact ha1.2 · intro ha simp only [uncontracted, Finset.mem_filter, Finset.mem_univ, true_and, ha, and_true, forall_const] have hx : φsΛ.getDual? a = none ↔ ¬ (φsΛ.getDual? a).isSome := by simp rw [hx] simp only [Bool.not_eq_true, Bool.eq_false_or_eq_true_self, true_and] intro h1 h2 simp_all · simp only [Nat.succ_eq_add_one, timeContract_insert_none, Algebra.smul_mul_assoc, instCommGroup.eq_1] rw [timeContract_of_not_gradingCompliant] simp only [ZeroMemClass.coe_zero, zero_mul, smul_zero] exact hg declNo: "7.12" - type: name name: WickContraction.wickTerm_insert_some line: 96 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WickTerm.lean#L96" isDef: false isThm: false docString: | 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. declString: | lemma wickTerm_insert_some (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (k : φsΛ.uncontracted) (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬ timeOrderRel φs[k] φ) : (φsΛ ↩Λ φ i (some k)).wickTerm = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩) • (φsΛ.sign • (contractStateAtIndex φ [φsΛ]ᵘᶜ ((uncontractedFieldOpEquiv φs φsΛ) (some k)) * φsΛ.timeContract) * 𝓝(ofFieldOpList (optionEraseZ [φsΛ]ᵘᶜ φ (uncontractedFieldOpEquiv φs φsΛ k)))) := by rw [wickTerm] by_cases hg : GradingCompliant φs φsΛ ∧ (𝓕 |>ₛ φ) = (𝓕 |>ₛ φs[k.1]) · by_cases hk : i.succAbove k < i · rw [WickContraction.timeContract_insert_some_of_not_lt] swap · exact hn _ hk · rw [normalOrder_uncontracted_some, sign_insert_some_of_lt φ φs φsΛ i k hk hg] simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc] congr 1 rw [mul_assoc, mul_assoc, mul_comm, mul_assoc, mul_assoc] simp · omega · have hik : i.succAbove ↑k ≠ i := Fin.succAbove_ne i ↑k rw [timeContract_insert_some_of_lt] swap · exact hlt _ · rw [normalOrder_uncontracted_some] rw [sign_insert_some_of_not_lt φ φs φsΛ i k hk hg] simp only [instCommGroup.eq_1, smul_smul, Algebra.smul_mul_assoc] congr 1 rw [mul_assoc, mul_assoc, mul_comm, mul_assoc, mul_assoc] simp · omega · rw [timeContract_insertAndContract_some] simp only [Fin.getElem_fin, not_and] at hg by_cases hg' : GradingCompliant φs φsΛ · have hg := hg hg' simp only [Nat.succ_eq_add_one, Fin.getElem_fin, ite_mul, Algebra.smul_mul_assoc, instCommGroup.eq_1, contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Fin.coe_cast, List.getElem_map, uncontractedList_getElem_uncontractedIndexEquiv_symm, List.get_eq_getElem, uncontractedListGet] by_cases h1 : i < i.succAbove ↑k · simp only [h1, ↓reduceIte, MulMemClass.coe_mul] rw [timeContract_zero_of_diff_grade] simp only [zero_mul, smul_zero] rw [superCommute_anPart_ofFieldOpF_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 [superCommute_anPart_ofFieldOpF_diff_grade_zero] simp only [zero_mul, smul_zero] exact hg exact fun a => hg (id (Eq.symm a)) · rw [timeContract_of_not_gradingCompliant] simp only [Nat.succ_eq_add_one, Fin.getElem_fin, mul_zero, ZeroMemClass.coe_zero, smul_zero, zero_mul, instCommGroup.eq_1] exact hg' declNo: "7.13" - type: name name: WickContraction.mul_wickTerm_eq_sum line: 177 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WickTerm status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WickTerm.lean#L177" isDef: false isThm: false docString: | 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. declString: | lemma mul_wickTerm_eq_sum (φ : 𝓕.FieldOp) (φs : List 𝓕.FieldOp) (i : Fin φs.length.succ) (φsΛ : WickContraction φs.length) (hlt : ∀ (k : Fin φs.length), timeOrderRel φ φs[k]) (hn : ∀ (k : Fin φs.length), i.succAbove k < i → ¬timeOrderRel φs[k] φ) : ofFieldOp φ * φsΛ.wickTerm = 𝓢(𝓕 |>ₛ φ, 𝓕 |>ₛ ⟨φs.get, (Finset.univ.filter (fun x => i.succAbove x < i))⟩) • ∑ (k : Option φsΛ.uncontracted), (φsΛ ↩Λ φ i k).wickTerm := by trans (φsΛ.sign • φsΛ.timeContract) * ((ofFieldOp φ) * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)) · have ht := Subalgebra.mem_center_iff.mp (Subalgebra.smul_mem (Subalgebra.center ℂ _) (WickContraction.timeContract φsΛ).2 (φsΛ.sign)) rw [wickTerm] rw [← mul_assoc, ht, mul_assoc] rw [ofFieldOp_mul_normalOrder_ofFieldOpList_eq_sum, Finset.mul_sum, uncontractedFieldOpEquiv_list_sum, Finset.smul_sum] simp only [instCommGroup.eq_1, Nat.succ_eq_add_one] congr 1 funext n match n with | none => rw [wickTerm_insert_none] simp only [contractStateAtIndex, uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_none', one_mul, Algebra.smul_mul_assoc, instCommGroup.eq_1, smul_smul] congr 1 rw [← mul_assoc, exchangeSign_mul_self] simp | some n => rw [wickTerm_insert_some _ _ _ _ _ (fun k => hlt k) (fun k a => hn k a)] simp only [uncontractedFieldOpEquiv, Equiv.optionCongr_apply, Equiv.coe_trans, Option.map_some', Function.comp_apply, finCongr_apply, Algebra.smul_mul_assoc, instCommGroup.eq_1, smul_smul] congr 1 · rw [← mul_assoc, exchangeSign_mul_self] rw [one_mul] · rw [← mul_assoc] congr 1 have ht := (WickContraction.timeContract φsΛ).prop rw [@Subalgebra.mem_center_iff] at ht rw [ht] declNo: "7.14" - type: h2 sectionNo: "7.3" content: "Wick's theorem" - type: name name: FieldSpecification.wicks_theorem line: 64 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WicksTheorem status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheorem.lean#L64" isDef: false isThm: true docString: | 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: 1. `timeOrder_eq_maxTimeField_mul_finset` is used to write `𝓣(φ₀…φₙ)` as `𝓢(φᵢ,φ₀…φᵢ₋₁) • φᵢ * 𝓣(φ₀…φᵢ₋₁φᵢ₊₁φₙ)` where `φᵢ` is the maximal time field in `φ₀…φₙ` 2. The induction hypothesis is then used on `𝓣(φ₀…φᵢ₋₁φᵢ₊₁φₙ)` to expand it as a sum over Wick contractions of `φ₀…φᵢ₋₁φᵢ₊₁φₙ`. 3. 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: 1. 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. declString: | theorem wicks_theorem : (φs : List 𝓕.FieldOp) → 𝓣(ofFieldOpList φs) = ∑ (φsΛ : WickContraction φs.length), φsΛ.wickTerm | [] => by rw [timeOrder_ofFieldOpList_nil] simp only [map_one, List.length_nil, Algebra.smul_mul_assoc] rw [sum_WickContraction_nil] simp only [wickTerm_empty_nil] | φ :: φs => by have ih := wicks_theorem (eraseMaxTimeField φ φs) 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] conv_rhs => rw [wicks_theorem_congr h1] conv_rhs => rw [insertLift_sum] apply Finset.sum_congr rfl intro c _ rw [Algebra.smul_mul_assoc, mul_wickTerm_eq_sum (maxTimeField φ φs) (eraseMaxTimeField φ φs) (maxTimeFieldPosFin φ φs) c] trans (1 : ℂ) • ∑ k : Option { x // x ∈ c.uncontracted }, (c ↩Λ (maxTimeField φ φs) (maxTimeFieldPosFin φ φs) k).wickTerm swap · simp [uncontractedListGet] rw [smul_smul] simp only [instCommGroup.eq_1, exchangeSign_mul_self, Nat.succ_eq_add_one, Algebra.smul_mul_assoc, Fintype.sum_option, timeContract_insert_none, Finset.univ_eq_attach, smul_add, one_smul, uncontractedListGet] · exact fun k => timeOrder_maxTimeField _ _ k · exact fun k => lt_maxTimeFieldPosFin_not_timeOrder _ _ k termination_by φs => φs.length declNo: "7.15" - type: h1 sectionNo: 8 content: "Normal-ordered Wick's theorem" - type: name name: WickContraction.EqTimeOnly.timeOrder_staticContract_of_not_mem line: 250 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeCond status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeCond.lean#L250" isDef: false isThm: false docString: | 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`. declString: | lemma timeOrder_staticContract_of_not_mem {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : ¬ φsΛ.EqTimeOnly) : 𝓣(φsΛ.staticContract.1) = 0 := by obtain ⟨i, j, hij, φsucΛ, rfl, hr⟩ := exists_join_singleton_of_not_eqTimeOnly φsΛ hl rw [join_staticContract] simp only [MulMemClass.coe_mul] rw [singleton_staticContract] rw [timeOrder_timeOrder_left] rw [timeOrder_superCommute_anPart_ofFieldOp_neq_time] simp only [zero_mul, map_zero] intro h simp_all declNo: "8.1" - type: name name: WickContraction.EqTimeOnly.staticContract_eq_timeContract_of_eqTimeOnly line: 99 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeCond status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeCond.lean#L99" isDef: false isThm: false docString: | Let `φs` be a list of `𝓕.FieldOp` and `φsΛ` a `WickContraction` of `φs` within which every contraction involves two `𝓕.FieldOp`s that have the same time, then `φsΛ.staticContract = φsΛ.timeContract`. declString: | lemma staticContract_eq_timeContract_of_eqTimeOnly (h : φsΛ.EqTimeOnly) : φsΛ.staticContract = φsΛ.timeContract := by simp only [staticContract, timeContract] apply congrArg funext a ext simp only [List.get_eq_getElem] rw [timeContract_of_timeOrderRel] apply timeOrderRel_of_eqTimeOnly_pair φsΛ rw [← finset_eq_fstFieldOfContract_sndFieldOfContract] exact a.2 exact h declNo: "8.2" - type: name name: WickContraction.EqTimeOnly.timeOrder_timeContract_mul_of_eqTimeOnly_left line: 196 fileName: PhysLean.QFT.PerturbationTheory.WickContraction.TimeCond status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/WickContraction/TimeCond.lean#L196" isDef: false isThm: false docString: | Let `φs` be a list of `𝓕.FieldOp`, `φsΛ` a `WickContraction` of `φs` within which every contraction involves two `𝓕.FieldOp`s that have the same time and `b` a general element in `𝓕.FieldOpAlgebra`. Then `𝓣(φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(b)`. This follows from properties of orderings and the ideal defining `𝓕.FieldOpAlgebra`. declString: | lemma timeOrder_timeContract_mul_of_eqTimeOnly_left {φs : List 𝓕.FieldOp} (φsΛ : WickContraction φs.length) (hl : φsΛ.EqTimeOnly) (b : 𝓕.FieldOpAlgebra) : 𝓣(φsΛ.timeContract.1 * b) = φsΛ.timeContract.1 * 𝓣(b) := by trans 𝓣(1 * φsΛ.timeContract.1 * b) simp only [one_mul] rw [timeOrder_timeContract_mul_of_eqTimeOnly_mid φsΛ hl] simp declNo: "8.3" - type: name name: FieldSpecification.FieldOpAlgebra.timeOrder_ofFieldOpList_eqTimeOnly line: 23 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WicksTheoremNormal status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheoremNormal.lean#L23" isDef: false isThm: false docString: | 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. declString: | lemma timeOrder_ofFieldOpList_eqTimeOnly (φs : List 𝓕.FieldOp) : 𝓣(ofFieldOpList φs) = ∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs)}), φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓣(𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) := by rw [static_wick_theorem φs] let e2 : WickContraction φs.length ≃ {φsΛ : WickContraction φs.length // φsΛ.EqTimeOnly} ⊕ {φsΛ : WickContraction φs.length // ¬ φsΛ.EqTimeOnly} := (Equiv.sumCompl _).symm rw [← e2.symm.sum_comp] simp only [Equiv.symm_symm, Algebra.smul_mul_assoc, Fintype.sum_sum_type, Equiv.sumCompl_apply_inl, Equiv.sumCompl_apply_inr, map_add, map_sum, map_smul, e2] simp only [staticWickTerm, Algebra.smul_mul_assoc, map_smul] conv_lhs => enter [2, 2, x] rw [timeOrder_timeOrder_left] rw [timeOrder_staticContract_of_not_mem _ x.2] simp only [Finset.univ_eq_attach, zero_mul, map_zero, smul_zero, Finset.sum_const_zero, add_zero] congr funext x rw [staticContract_eq_timeContract_of_eqTimeOnly] rw [timeOrder_timeContract_mul_of_eqTimeOnly_left] exact x.2 exact x.2 declNo: "8.4" - type: name name: FieldSpecification.FieldOpAlgebra.normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty line: 92 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WicksTheoremNormal status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheoremNormal.lean#L92" isDef: false isThm: false docString: | 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` declString: | lemma normalOrder_timeOrder_ofFieldOpList_eq_eqTimeOnly_empty (φs : List 𝓕.FieldOp) : 𝓣(𝓝(ofFieldOpList φs)) = 𝓣(ofFieldOpList φs) - ∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}), φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓣(𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) := by rw [timeOrder_ofFieldOpList_eq_eqTimeOnly_empty] simp declNo: "8.5" - type: name name: FieldSpecification.FieldOpAlgebra.timeOrder_haveEqTime_split line: 110 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WicksTheoremNormal status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheoremNormal.lean#L110" isDef: false isThm: false docString: | 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. declString: | lemma timeOrder_haveEqTime_split (φs : List 𝓕.FieldOp) : 𝓣(ofFieldOpList φs) = (∑ (φsΛ : {φsΛ : WickContraction φs.length // ¬ HaveEqTime φsΛ}), φsΛ.1.sign • φsΛ.1.timeContract.1 * 𝓝(ofFieldOpList [φsΛ.1]ᵘᶜ)) + ∑ (φsΛ : {φsΛ // φsΛ.EqTimeOnly (φs := φs) ∧ φsΛ ≠ empty}), φsΛ.1.sign • φsΛ.1.timeContract * (∑ φssucΛ : { φssucΛ : WickContraction [φsΛ.1]ᵘᶜ.length // ¬ φssucΛ.HaveEqTime }, φssucΛ.1.wickTerm) := by rw [wicks_theorem] simp only [wickTerm] let e1 : WickContraction φs.length ≃ {φsΛ // HaveEqTime φsΛ} ⊕ {φsΛ // ¬ HaveEqTime φsΛ} := by exact (Equiv.sumCompl HaveEqTime).symm rw [← e1.symm.sum_comp] simp only [Equiv.symm_symm, Algebra.smul_mul_assoc, Fintype.sum_sum_type, Equiv.sumCompl_apply_inl, Equiv.sumCompl_apply_inr, ne_eq, sub_left_inj, e1] rw [add_comm] congr 1 let f : WickContraction φs.length → 𝓕.FieldOpAlgebra := fun φsΛ => φsΛ.sign • (φsΛ.timeContract.1 * 𝓝(ofFieldOpList [φsΛ]ᵘᶜ)) change ∑ (φsΛ : {φsΛ : WickContraction φs.length // HaveEqTime φsΛ}), f φsΛ.1 = _ rw [sum_haveEqTime] congr funext φsΛ simp only [f] conv_lhs => enter [2, φsucΛ] rw [← Algebra.smul_mul_assoc] rw [join_sign_timeContract φsΛ.1 φsucΛ.1] conv_lhs => enter [2, φsucΛ] rw [mul_assoc] rw [← Finset.mul_sum, ← Algebra.smul_mul_assoc] congr funext φsΛ' simp only [ne_eq, Algebra.smul_mul_assoc] congr 1 rw [@join_uncontractedListGet] declNo: "8.6" - type: name name: FieldSpecification.FieldOpAlgebra.wicks_theorem_normal_order line: 218 fileName: PhysLean.QFT.PerturbationTheory.FieldOpAlgebra.WicksTheoremNormal status: "complete" link: "https://github.com/HEPLean/PhysLean/blob/master/PhysLean/PerturbationTheory/FieldOpAlgebra/WicksTheoremNormal.lean#L218" isDef: false isThm: true docString: | 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. declString: | theorem wicks_theorem_normal_order : (φs : List 𝓕.FieldOp) → 𝓣(𝓝(ofFieldOpList φs)) = ∑ (φsΛ : {φsΛ : WickContraction φs.length // ¬ HaveEqTime φsΛ}), φsΛ.1.wickTerm | [] => wicks_theorem_normal_order_empty | φ :: φs => by rw [normalOrder_timeOrder_ofFieldOpList_eq_not_haveEqTime_sub_inductive] simp only [Algebra.smul_mul_assoc, ne_eq, add_right_eq_self] apply Finset.sum_eq_zero intro φsΛ hφsΛ simp only [smul_eq_zero] right have ih := wicks_theorem_normal_order [φsΛ.1]ᵘᶜ rw [ih] simp [wickTerm] termination_by φs => φs.length decreasing_by simp only [uncontractedListGet, List.length_cons, List.length_map, gt_iff_lt] rw [uncontractedList_length_eq_card] have hc := uncontracted_card_eq_iff φsΛ.1 simp only [List.length_cons, φsΛ.2.2, iff_false] at hc have hc' := uncontracted_card_le φsΛ.1 simp_all only [Algebra.smul_mul_assoc, List.length_cons, Finset.mem_univ, gt_iff_lt] omega declNo: "8.7"