From c768a9248af9f9e7ad44f03f485241c653388805 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sat, 14 Nov 2026 11:43:37 -0500 Subject: [PATCH 01/11] feat(QFT): define Glimm-Jaffe Euclidean field axioms Co-authored-by: Codex --- Physlib.lean | 2 + Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 158 +++++++++++++++ Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 196 +++++++++++++++++++ docs/references.bib | 20 ++ scripts/lint/exemptions/spellingWords.txt | 15 ++ 5 files changed, 391 insertions(+) create mode 100644 Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean create mode 100644 Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean diff --git a/Physlib.lean b/Physlib.lean index d78a320603..391cf07b5f 100644 --- a/Physlib.lean +++ b/Physlib.lean @@ -327,6 +327,8 @@ public import Physlib.ProbabilisticTheory.Weight.Basic public import Physlib.ProbabilisticTheory.Weight.Extension public import Physlib.QFT.AnomalyCancellation.Basic public import Physlib.QFT.AnomalyCancellation.GroupActions +public import Physlib.QFT.Euclidean.GlimmJaffe.Axioms +public import Physlib.QFT.Euclidean.GlimmJaffe.Basic public import Physlib.QFT.PerturbationTheory.CreateAnnihilate public import Physlib.QFT.PerturbationTheory.FeynmanDiagrams.Basic public import Physlib.QFT.PerturbationTheory.FieldOpFreeAlgebra.Basic diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean new file mode 100644 index 0000000000..683bd13334 --- /dev/null +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -0,0 +1,158 @@ +/- +Copyright (c) 2025 Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. All rights reserved. +Copyright (c) 2026 Sergey A. Cherkis. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim +-/ +module + +public import Physlib.QFT.Euclidean.GlimmJaffe.Basic + +/-! +# Glimm–Jaffe axioms + +The measure and generating-functional formulation of the Euclidean field axioms. + +## i. Overview + +We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity +(OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and +clustering and ergodicity (OS4). These are assumptions on a probability measure on +real tempered distributions; no existence or reconstruction theorem is asserted. + +The source conventions are retained: `d` is the total dimension and `2 ≤ d`; +positive-time tests have topological support in the open positive-time half-space; +OS1 bounds the sum of the integrals of `‖f‖` and `‖f‖^p`; and OS3 asserts +nonnegativity of the real part of the reflected quadratic form. The `p = 2` +condition includes convergence of mollified two-point functions away from zero, +not merely local integrability of a possibly nonexistent limit. + +The source bundles both clustering and ergodicity. We retain this convention without +asserting equivalence between them. Real reflection positivity and polynomial clustering +are supplied separately, as in the source. OS4 uses exponentials without a factor of `i`, +whereas the characteristic functional in OS0–OS3 includes that factor. +This numbering differs from the distributional Osterwalder–Schrader axioms E0–E4. + +## ii. Key results + +* `SatisfiesAxioms`: the bundled Glimm–Jaffe conditions from `SatisfiesAllOS` in `OSforGFF`. +* `TwoPointIntegrable`: the explicit mollifier-limit condition at the OS1 endpoint. +* `OS3ReflectionPositivityReal` and `OS4PolynomialClustering`: separate source variants. + +## iii. Table of contents + +- A. Analyticity and regularity +- B. Euclidean invariance and reflection positivity +- C. Clustering and ergodicity +- D. Bundled axioms + +## iv. References + +* Glimm and Jaffe, *Quantum Physics*. [ref: glimm1987quantum] +* Cherkis et al., *OSforGFF*, `OS/Axioms.lean`. [ref: osforgff] +-/ + +@[expose] public section +noncomputable section + +open MeasureTheory Filter +open scoped SchwartzMap Topology + +namespace GlimmJaffe + +variable {d : ℕ} [Fact (2 ≤ d)] + +/-! ## A. Analyticity and regularity -/ + +/-- OS0: the characteristic functional is entire on every finite-dimensional complex +family of Schwartz tests. -/ +def OS0Analyticity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (n : ℕ) (J : Fin n → 𝓢(EuclideanSpacetime d, ℂ)), + AnalyticOn ℂ (fun z : Fin n → ℂ => generatingFunctional μ (∑ i, z i • J i)) Set.univ + +/-- The endpoint condition for OS1: mollified second moments converge at every nonzero +separation to a locally integrable function. No limit is required at coincidence. -/ +def TwoPointIntegrable (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∃ K : EuclideanSpacetime d → ℝ, LocallyIntegrable K volume ∧ + ∀ x, x ≠ 0 → Tendsto (fun n => smearedTwoPointFunction μ n x) atTop (𝓝 (K x)) + +/-- OS1: exponential growth controlled by the integrals of `‖f‖` and `‖f‖^p`, +for some `1 ≤ p ≤ 2`, with the additional two-point condition when `p = 2`. -/ +def OS1Regularity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∃ p c : ℝ, 1 ≤ p ∧ p ≤ 2 ∧ 0 < c ∧ + (∀ f : 𝓢(EuclideanSpacetime d, ℂ), + ‖generatingFunctional μ f‖ ≤ + Real.exp (c * ((∫ x, ‖f x‖) + ∫ x, ‖f x‖ ^ p))) ∧ + (p = 2 → TwoPointIntegrable μ) + +/-! ## B. Euclidean invariance and reflection positivity -/ + +/-- OS2: invariance of the characteristic functional under the full Euclidean group. -/ +def OS2EuclideanInvariance (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (g : EuclideanGroup d) (f : 𝓢(EuclideanSpacetime d, ℂ)), + generatingFunctional μ f = generatingFunctional μ (euclideanAction g f) + +/-- OS3 in the source's complex formulation: the real part of every reflected +quadratic form is nonnegative. Reflection includes complex conjugation of the test. -/ +def OS3ReflectionPositivity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (n : ℕ) (f : Fin n → PositiveTimeTestFunction d) (c : Fin n → ℂ), + 0 ≤ (∑ i, ∑ j, starRingEnd ℂ (c i) * c j * + generatingFunctional μ ((f i).val - reflectedConjugate (f j).val)).re + +/-- The separate real-test, real-coefficient formulation of reflection positivity. +No equivalence with complex reflection positivity is asserted here. -/ +def OS3ReflectionPositivityReal (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (n : ℕ) (f : Fin n → 𝓢(EuclideanSpacetime d, ℝ)), + (∀ i, tsupport (f i) ⊆ {x | 0 < x timeIndex}) → ∀ c : Fin n → ℝ, + 0 ≤ ∑ i, ∑ j, c i * c j * (generatingFunctionalReal μ + (f i - SchwartzMap.compCLMOfContinuousLinearEquiv ℝ timeReflection (f j))).re + +/-! ## C. Clustering and ergodicity -/ + +/-- OS4 clustering for real tests: the characteristic functional factorizes as +their Euclidean separation tends to infinity, uniformly over translation directions. -/ +def OS4Clustering (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (f g : 𝓢(EuclideanSpacetime d, ℝ)) (ε : ℝ), 0 < ε → + ∃ R : ℝ, 0 < R ∧ ∀ a : EuclideanSpacetime d, R < ‖a‖ → + ‖generatingFunctionalReal μ (f + SchwartzMap.compSubConstCLM ℝ a g) - + generatingFunctionalReal μ f * generatingFunctionalReal μ g‖ < ε + +/-- OS4 ergodicity: centered time averages of finite linear combinations of +`exp(⟨ω, f⟩)` converge to zero in mean square. This retains the source's integral +formulation, with the centering inside the time integral. -/ +def OS4Ergodicity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(EuclideanSpacetime d, ℂ)), + let A : FieldConfiguration d → ℂ := fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) + Tendsto (fun T : ℝ => + ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, + (A (timeTranslation s ω) - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) + atTop (𝓝 0) + +/-- Polynomial clustering at exponent `α > 0`, supplied separately from the bundled +axioms. The correlations here use `exp(⟨ω, f⟩)`, without the characteristic factor `i`. -/ +def OS4PolynomialClustering (μ : ProbabilityMeasure (FieldConfiguration d)) + (α : ℝ) (_hα : 0 < α) : Prop := + ∀ f g : 𝓢(EuclideanSpacetime d, ℂ), ∃ c : ℝ, 0 ≤ c ∧ ∀ s : ℝ, 0 ≤ s → + ‖(∫ ω, Complex.exp (pairing ω f + pairing (timeTranslation s ω) g) ∂μ.toMeasure) - + (∫ ω, Complex.exp (pairing ω f) ∂μ.toMeasure) * + (∫ ω, Complex.exp (pairing ω g) ∂μ.toMeasure)‖ ≤ c * (1 + s) ^ (-α) + +/-! ## D. Bundled axioms -/ + +/-- The Glimm–Jaffe conditions bundled as in `SatisfiesAllOS` in `OSforGFF`. +Clustering and ergodicity are both required; polynomial clustering is separate. -/ +structure SatisfiesAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where + /-- OS0: entire dependence on finite families of complex tests. -/ + analytic : OS0Analyticity μ + /-- OS1: the exponential bound and endpoint two-point condition. -/ + regular : OS1Regularity μ + /-- OS2: full Euclidean invariance. -/ + euclideanInvariant : OS2EuclideanInvariance μ + /-- OS3: reflection positivity for complex positive-time tests and coefficients. -/ + reflectionPositive : OS3ReflectionPositivity μ + /-- OS4: clustering under arbitrary large Euclidean translations. -/ + clustering : OS4Clustering μ + /-- OS4: mean-square ergodicity under time translation. -/ + ergodic : OS4Ergodicity μ + +end GlimmJaffe diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean new file mode 100644 index 0000000000..ace9fcf2ed --- /dev/null +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -0,0 +1,196 @@ +/- +Copyright (c) 2025 Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. All rights reserved. +Copyright (c) 2026 Sergey A. Cherkis. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim +-/ +module + +-- Explicit public imports are needed for the bump and measurable-space instances; +-- their private transitive imports through Schwartz space do not expose the instances. +public import Mathlib.Analysis.Calculus.BumpFunction.InnerProduct +public import Mathlib.Analysis.Calculus.BumpFunction.Normed +public import Mathlib.Analysis.Distribution.SchwartzSpace.Basic +public import Mathlib.Analysis.LocallyConvex.WeakDual +public import Mathlib.Analysis.Normed.Lp.MeasurableSpace +public import Mathlib.MeasureTheory.Measure.ProbabilityMeasure +public import Physlib.SpaceAndTime.Space.EuclideanGroup.AffineGroup + +/-! +# Glimm–Jaffe Euclidean fields + +Test functions, field configurations and generating functionals for a real scalar field. + +## i. Overview + +This is the measure-based setup used by `OSforGFF`, adapted to Mathlib and Physlib. +The parameter `d` counts all Euclidean spacetime coordinates, with coordinate zero +designated as time. Field configurations are real tempered distributions with their +weak dual topology and cylinder sigma algebra. Their pairing with complex Schwartz +functions is extended complex linearly. + +Translations use Mathlib's Schwartz pullback; Euclidean transformations use Physlib's +full Euclidean group, including reflections. The reflected conjugate is a named map, +so it does not change the pointwise `Star` instance on Schwartz functions. + +## ii. Key results + +* `FieldConfiguration`: real tempered distributions with the cylinder sigma algebra. +* `generatingFunctional` and `generatingFunctionalReal`: characteristic functionals. +* `reflectedConjugate`: conjugation combined with Euclidean time reflection. +* `smearedTwoPointFunction`: the two-point function at a specified mollifier scale. + +## iii. Table of contents + +- A. Field configurations and generating functionals +- B. Euclidean symmetries and positive time +- C. Smeared two-point functions + +## iv. References + +* Glimm and Jaffe, *Quantum Physics*. [ref: glimm1987quantum] +* Cherkis et al., *OSforGFF*, `Spacetime/Basic.lean`, + `Spacetime/PositiveTimeTestFunction.lean`, `Spacetime/TimeTranslation.lean`, + and `Schwinger/TwoPoint.lean`. [ref: osforgff] +-/ + +@[expose] public section +noncomputable section + +open MeasureTheory +open scoped SchwartzMap + +namespace GlimmJaffe + +/-! ## A. Field configurations and generating functionals -/ + +/-- Euclidean spacetime with `d` total coordinates; coordinate zero is time. -/ +abbrev EuclideanSpacetime (d : ℕ) := EuclideanSpace ℝ (Fin d) + +/-- Real scalar field configurations, with the weak dual topology on tempered distributions. -/ +abbrev FieldConfiguration (d : ℕ) := WeakDual ℝ (𝓢(EuclideanSpacetime d, ℝ)) + +/-- The cylinder sigma algebra generated by all real Schwartz evaluations. -/ +instance fieldConfigurationMeasurableSpace (d : ℕ) : MeasurableSpace (FieldConfiguration d) := + MeasurableSpace.comap (fun ω f => ω f) inferInstance + +variable {d : ℕ} + +/-- The complex-linear extension of the pairing of a real field with a Schwartz test. -/ +def pairing (ω : FieldConfiguration d) (f : 𝓢(EuclideanSpacetime d, ℂ)) : ℂ := + (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) + + Complex.I * (ω (SchwartzMap.postcompCLM Complex.imCLM f) : ℂ) + +/-- The characteristic functional `Z[f] = ∫ exp(i ⟨ω, f⟩) dμ` on complex tests. -/ +def generatingFunctional (μ : ProbabilityMeasure (FieldConfiguration d)) + (f : 𝓢(EuclideanSpacetime d, ℂ)) : ℂ := + ∫ ω, Complex.exp (Complex.I * pairing ω f) ∂μ.toMeasure + +/-- The characteristic functional restricted to real Schwartz tests. -/ +def generatingFunctionalReal (μ : ProbabilityMeasure (FieldConfiguration d)) + (f : 𝓢(EuclideanSpacetime d, ℝ)) : ℂ := + ∫ ω, Complex.exp (Complex.I * (ω f : ℂ)) ∂μ.toMeasure + +/-! ## B. Euclidean symmetries and positive time -/ + +/-- Pullback of a complex test by the inverse of a full Euclidean transformation. -/ +def euclideanAction (g : EuclideanGroup d) : + 𝓢(EuclideanSpacetime d, ℂ) →L[ℂ] 𝓢(EuclideanSpacetime d, ℂ) := + let e := EuclideanGroup.toAffineIsometryHom g⁻¹ + SchwartzMap.compCLMOfAntilipschitz ℂ (K := 1) + (g := fun x => e.linearIsometryEquiv x + e 0) + (e.linearIsometryEquiv.toContinuousLinearMap.hasTemperateGrowth.add (by fun_prop)) + (by + have he : (fun x => e.linearIsometryEquiv x + e 0) = e := by + funext x + simpa only [vadd_eq_add, add_zero] using (e.map_vadd 0 x).symm + rw [he] + exact e.antilipschitzWith) + +/-- The Euclidean action is pullback by the inverse affine isometry. -/ +@[simp] +lemma euclideanAction_apply (g : EuclideanGroup d) (f : 𝓢(EuclideanSpacetime d, ℂ)) + (x : EuclideanSpacetime d) : + euclideanAction g f x = f (EuclideanGroup.toAffineIsometryHom g⁻¹ x) := by + change f (_ + _) = _ + congr 1 + simpa only [vadd_eq_add, add_zero] using + ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 x).symm + +variable [Fact (2 ≤ d)] + +/-- The distinguished Euclidean time coordinate. -/ +def timeIndex : Fin d := ⟨0, by have := Fact.out (p := 2 ≤ d); omega⟩ + +/-- Reflection of the time coordinate, as a continuous linear equivalence. -/ +def timeReflection : EuclideanSpacetime d ≃L[ℝ] EuclideanSpacetime d := + (EuclideanSpace.equiv (Fin d) ℝ).trans + ((ContinuousLinearEquiv.piCongrRight fun i : Fin d => + if i = timeIndex then ContinuousLinearEquiv.neg ℝ else ContinuousLinearEquiv.refl ℝ ℝ).trans + (EuclideanSpace.equiv (Fin d) ℝ).symm) + +/-- Time reflection negates the time coordinate and fixes every spatial coordinate. -/ +lemma timeReflection_apply (x : EuclideanSpacetime d) (i : Fin d) : + timeReflection x i = if i = timeIndex then -x i else x i := by + change (if i = timeIndex then ContinuousLinearEquiv.neg ℝ else + ContinuousLinearEquiv.refl ℝ ℝ) (x i) = _ + split <;> rfl + +/-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. -/ +def reflectedConjugate (f : 𝓢(EuclideanSpacetime d, ℂ)) : 𝓢(EuclideanSpacetime d, ℂ) := + SchwartzMap.postcompCLM Complex.conjCLE.toContinuousLinearMap + (SchwartzMap.compCLMOfContinuousLinearEquiv ℝ timeReflection f) + +/-- The reflected conjugate includes both time reflection and complex conjugation. -/ +@[simp] +lemma reflectedConjugate_apply (f : 𝓢(EuclideanSpacetime d, ℂ)) + (x : EuclideanSpacetime d) : + reflectedConjugate f x = starRingEnd ℂ (f (timeReflection x)) := rfl + +/-- Applying the reflected conjugation twice recovers the original test. -/ +@[simp] +lemma reflectedConjugate_involutive (f : 𝓢(EuclideanSpacetime d, ℂ)) : + reflectedConjugate (reflectedConjugate f) = f := by + ext x + simp only [reflectedConjugate_apply, starRingEnd_self_apply] + congr 1 + ext i + simp only [timeReflection_apply] + split <;> simp_all + +/-- Complex Schwartz functions whose topological support lies strictly at positive time. +This retains the support convention of `OSforGFF`. -/ +abbrev PositiveTimeTestFunction (d : ℕ) [Fact (2 ≤ d)] := + {f : 𝓢(EuclideanSpacetime d, ℂ) | tsupport f ⊆ {x | 0 < x timeIndex}} + +/-- Time translation of a field by duality: `(T_s ω)(f) = ω(x ↦ f(x - s e₀))`. +The corresponding source convention on test functions is `T_s f(x) = f(x + s e₀)`. -/ +def timeTranslation (s : ℝ) (ω : FieldConfiguration d) : FieldConfiguration d := + ω.comp (SchwartzMap.compSubConstCLM ℝ (EuclideanSpace.single timeIndex s)) + +/-! ## C. Smeared two-point functions -/ + +omit [Fact (2 ≤ d)] in +/-- Standard bump with outer radius `1 / (n + 1)` and half that inner radius. -/ +def standardMollifier (n : ℕ) : ContDiffBump (0 : EuclideanSpacetime d) where + rIn := 1 / (2 * (n + 1 : ℕ)) + rOut := 1 / (n + 1 : ℕ) + rIn_pos := by positivity + rIn_lt_rOut := by + have hn : (0 : ℝ) < (n + 1 : ℕ) := by positivity + exact one_div_lt_one_div_of_lt hn (by linarith) + +omit [Fact (2 ≤ d)] in +/-- The normalized standard mollifier as a real Schwartz test, with integral one. -/ +def mollifierTest (n : ℕ) : 𝓢(EuclideanSpacetime d, ℝ) := + ((standardMollifier (d := d) n).hasCompactSupport_normed (μ := volume)).toSchwartzMap + (standardMollifier n).contDiff_normed + +omit [Fact (2 ≤ d)] in +/-- The second moment smeared at zero and at `x` with normalized mollifiers of scale `n`. -/ +def smearedTwoPointFunction (μ : ProbabilityMeasure (FieldConfiguration d)) + (n : ℕ) (x : EuclideanSpacetime d) : ℝ := + ∫ ω, ω (SchwartzMap.compSubConstCLM ℝ x (mollifierTest n)) * ω (mollifierTest n) + ∂μ.toMeasure + +end GlimmJaffe diff --git a/docs/references.bib b/docs/references.bib index 8ded2add07..b0ac60de3d 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -9,6 +9,26 @@ # Do not add Zulip links to the .bib file, keep them as plain URLs within the Lean files +@book{glimm1987quantum, + author = {Glimm, James and Jaffe, Arthur}, + title = {Quantum Physics: A Functional Integral Point of View}, + edition = {2}, + publisher = {Springer}, + address = {New York}, + year = {1987}, + doi = {10.1007/978-1-4612-4728-9} +} + +@misc{osforgff, + author = {Cherkis, Sergey A. and Douglas, Michael R. and Hoback, Sarah and + Mei, Anna and Nissim, Ron}, + title = {{OSforGFF}: A Lean formalization of the Gaussian free field}, + year = {2026}, + howpublished = {\url{https://github.com/mrdouglasny/OSforGFF}}, + note = {Definitions adapted from OSforGFF/OS/Axioms.lean and its spacetime + and Schwinger support modules, accessed 2026-11-14} +} + @article{Allanach:2021yjy, author = {Allanach, B. C. and Madigan, Maeve and Tooby-Smith, Joseph}, diff --git a/scripts/lint/exemptions/spellingWords.txt b/scripts/lint/exemptions/spellingWords.txt index ff0385457d..86e0c2b8a9 100644 --- a/scripts/lint/exemptions/spellingWords.txt +++ b/scripts/lint/exemptions/spellingWords.txt @@ -1,4 +1,19 @@ boundedness +analyticity +Cherkis +clustering +cylinder +ergodicity +functionals +Glimm +mollified +mollifier +osforgff +pairing +pullback +reconstruction +reflection +reflections coefficient comp complexification From c494bdd50f0eb62bc63a75b33cf9715285547bf3 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sat, 14 Nov 2026 16:22:11 -0500 Subject: [PATCH 02/11] fix(QFT): match OSforGFF smeared two-point definition Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 4 +- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 59 +++++++++++++------- 2 files changed, 43 insertions(+), 20 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index 683bd13334..bbb4ef6206 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -74,7 +74,9 @@ def OS0Analyticity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := separation to a locally integrable function. No limit is required at coincidence. -/ def TwoPointIntegrable (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := ∃ K : EuclideanSpacetime d → ℝ, LocallyIntegrable K volume ∧ - ∀ x, x ≠ 0 → Tendsto (fun n => smearedTwoPointFunction μ n x) atTop (𝓝 (K x)) + ∀ x, x ≠ 0 → Tendsto (fun n => + SmearedTwoPointFunction μ (standardBumpSequence (n + 1) (Nat.succ_ne_zero n)) x) + atTop (𝓝 (K x)) /-- OS1: exponential growth controlled by the integrals of `‖f‖` and `‖f‖^p`, for some `1 ≤ p ≤ 2`, with the additional two-point condition when `p = 2`. -/ diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index ace9fcf2ed..2d151cd3d9 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -38,7 +38,7 @@ so it does not change the pointwise `Star` instance on Schwartz functions. * `FieldConfiguration`: real tempered distributions with the cylinder sigma algebra. * `generatingFunctional` and `generatingFunctionalReal`: characteristic functionals. * `reflectedConjugate`: conjugation combined with Euclidean time reflection. -* `smearedTwoPointFunction`: the two-point function at a specified mollifier scale. +* `SmearedTwoPointFunction`: the two-point function smeared with an arbitrary normalized bump. ## iii. Table of contents @@ -51,7 +51,7 @@ so it does not change the pointwise `Star` instance on Schwartz functions. * Glimm and Jaffe, *Quantum Physics*. [ref: glimm1987quantum] * Cherkis et al., *OSforGFF*, `Spacetime/Basic.lean`, `Spacetime/PositiveTimeTestFunction.lean`, `Spacetime/TimeTranslation.lean`, - and `Schwinger/TwoPoint.lean`. [ref: osforgff] + `Schwinger/Defs.lean`, and `Schwinger/TwoPoint.lean`. [ref: osforgff] -/ @[expose] public section @@ -171,26 +171,47 @@ def timeTranslation (s : ℝ) (ω : FieldConfiguration d) : FieldConfiguration d /-! ## C. Smeared two-point functions -/ omit [Fact (2 ≤ d)] in -/-- Standard bump with outer radius `1 / (n + 1)` and half that inner radius. -/ -def standardMollifier (n : ℕ) : ContDiffBump (0 : EuclideanSpacetime d) where - rIn := 1 / (2 * (n + 1 : ℕ)) - rOut := 1 / (n + 1 : ℕ) - rIn_pos := by positivity - rIn_lt_rOut := by - have hn : (0 : ℝ) < (n + 1 : ℕ) := by positivity - exact one_div_lt_one_div_of_lt hn (by linarith) +/-- The real `n`-point Schwinger function, the expectation of the product of field evaluations. -/ +def SchwingerFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) (n : ℕ) + (f : Fin n → 𝓢(EuclideanSpacetime d, ℝ)) : ℝ := + ∫ ω, (∏ i, ω (f i)) ∂dμ_config.toMeasure + +omit [Fact (2 ≤ d)] in +/-- The real two-point Schwinger function evaluated on two Schwartz tests. -/ +def SchwingerFunction₂ (dμ_config : ProbabilityMeasure (FieldConfiguration d)) + (f g : 𝓢(EuclideanSpacetime d, ℝ)) : ℝ := + SchwingerFunction dμ_config 2 ![f, g] + +omit [Fact (2 ≤ d)] in +/-- Convert a smooth bump centered at zero to a real Schwartz test with integral one. -/ +def bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpacetime d)) : + 𝓢(EuclideanSpacetime d, ℝ) := + (φ.hasCompactSupport_normed (μ := volume)).toSchwartzMap φ.contDiff_normed + +omit [Fact (2 ≤ d)] in +/-- Translate a real Schwartz test by `a`, with value `f (x - a)` at `x`. -/ +def translateSchwartz (f : 𝓢(EuclideanSpacetime d, ℝ)) (a : EuclideanSpacetime d) : + 𝓢(EuclideanSpacetime d, ℝ) := + SchwartzMap.compSubConstCLM ℝ a f omit [Fact (2 ≤ d)] in -/-- The normalized standard mollifier as a real Schwartz test, with integral one. -/ -def mollifierTest (n : ℕ) : 𝓢(EuclideanSpacetime d, ℝ) := - ((standardMollifier (d := d) n).hasCompactSupport_normed (μ := volume)).toSchwartzMap - (standardMollifier n).contDiff_normed +/-- The two-point Schwinger function smeared at `x` and zero with an arbitrary normalized bump. +This follows `SmearedTwoPointFunction` in `OSforGFF`, with the bump supplied independently +of the standard sequence used in the OS1 endpoint condition. -/ +def SmearedTwoPointFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) + (φ : ContDiffBump (0 : EuclideanSpacetime d)) (x : EuclideanSpacetime d) : ℝ := + SchwingerFunction₂ dμ_config + (translateSchwartz (bumpToSchwartz φ) x) + (bumpToSchwartz φ) omit [Fact (2 ≤ d)] in -/-- The second moment smeared at zero and at `x` with normalized mollifiers of scale `n`. -/ -def smearedTwoPointFunction (μ : ProbabilityMeasure (FieldConfiguration d)) - (n : ℕ) (x : EuclideanSpacetime d) : ℝ := - ∫ ω, ω (SchwartzMap.compSubConstCLM ℝ x (mollifierTest n)) * ω (mollifierTest n) - ∂μ.toMeasure +/-- The standard bump sequence from `OSforGFF`, with outer radius `1 / n` for nonzero `n`. -/ +def standardBumpSequence (n : ℕ) (hn : n ≠ 0) : ContDiffBump (0 : EuclideanSpacetime d) where + rIn := 1 / (2 * n) + rOut := 1 / n + rIn_pos := by positivity + rIn_lt_rOut := by + have hn' : (0 : ℝ) < n := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn) + exact one_div_lt_one_div_of_lt hn' (by linarith) end GlimmJaffe From d997ca04fd5904a24e82edb6dbd0640b11db73e6 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sat, 14 Nov 2026 16:41:29 -0500 Subject: [PATCH 03/11] refactor(QFT): remove real reflection-positivity variant Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 17 +++++------------ 1 file changed, 5 insertions(+), 12 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index bbb4ef6206..a41ea8ff33 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -28,16 +28,17 @@ condition includes convergence of mollified two-point functions away from zero, not merely local integrability of a possibly nonexistent limit. The source bundles both clustering and ergodicity. We retain this convention without -asserting equivalence between them. Real reflection positivity and polynomial clustering -are supplied separately, as in the source. OS4 uses exponentials without a factor of `i`, -whereas the characteristic functional in OS0–OS3 includes that factor. +asserting equivalence between them. Polynomial clustering is supplied separately, as in +the source. Clustering uses the characteristic functional on real tests. Ergodicity and +polynomial clustering use exponentials without a factor of `i`, whereas the characteristic +functional in OS0–OS3 and clustering includes that factor. This numbering differs from the distributional Osterwalder–Schrader axioms E0–E4. ## ii. Key results * `SatisfiesAxioms`: the bundled Glimm–Jaffe conditions from `SatisfiesAllOS` in `OSforGFF`. * `TwoPointIntegrable`: the explicit mollifier-limit condition at the OS1 endpoint. -* `OS3ReflectionPositivityReal` and `OS4PolynomialClustering`: separate source variants. +* `OS4PolynomialClustering`: the separate polynomial clustering condition from the source. ## iii. Table of contents @@ -101,14 +102,6 @@ def OS3ReflectionPositivity (μ : ProbabilityMeasure (FieldConfiguration d)) : P 0 ≤ (∑ i, ∑ j, starRingEnd ℂ (c i) * c j * generatingFunctional μ ((f i).val - reflectedConjugate (f j).val)).re -/-- The separate real-test, real-coefficient formulation of reflection positivity. -No equivalence with complex reflection positivity is asserted here. -/ -def OS3ReflectionPositivityReal (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∀ (n : ℕ) (f : Fin n → 𝓢(EuclideanSpacetime d, ℝ)), - (∀ i, tsupport (f i) ⊆ {x | 0 < x timeIndex}) → ∀ c : Fin n → ℝ, - 0 ≤ ∑ i, ∑ j, c i * c j * (generatingFunctionalReal μ - (f i - SchwartzMap.compCLMOfContinuousLinearEquiv ℝ timeReflection (f j))).re - /-! ## C. Clustering and ergodicity -/ /-- OS4 clustering for real tests: the characteristic functional factorizes as From 07a29eabf6caec51430b2105c2caec1fbf9e3144 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sat, 14 Nov 2026 16:48:17 -0500 Subject: [PATCH 04/11] refactor(QFT): name the axiom bundle GlimmJaffeAxioms Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index a41ea8ff33..573a042679 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -36,7 +36,7 @@ This numbering differs from the distributional Osterwalder–Schrader axioms E0 ## ii. Key results -* `SatisfiesAxioms`: the bundled Glimm–Jaffe conditions from `SatisfiesAllOS` in `OSforGFF`. +* `GlimmJaffeAxioms`: the bundled Glimm–Jaffe conditions from `SatisfiesAllOS` in `OSforGFF`. * `TwoPointIntegrable`: the explicit mollifier-limit condition at the OS1 endpoint. * `OS4PolynomialClustering`: the separate polynomial clustering condition from the source. @@ -136,7 +136,7 @@ def OS4PolynomialClustering (μ : ProbabilityMeasure (FieldConfiguration d)) /-- The Glimm–Jaffe conditions bundled as in `SatisfiesAllOS` in `OSforGFF`. Clustering and ergodicity are both required; polynomial clustering is separate. -/ -structure SatisfiesAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where +structure GlimmJaffeAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where /-- OS0: entire dependence on finite families of complex tests. -/ analytic : OS0Analyticity μ /-- OS1: the exponential bound and endpoint two-point condition. -/ From c2b00dea5e8d181a363f1d3762531234a351f87a Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sat, 14 Nov 2026 16:54:52 -0500 Subject: [PATCH 05/11] refactor(QFT): retain only ergodicity for OS4 Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 41 +++++--------------- scripts/lint/exemptions/spellingWords.txt | 1 - 2 files changed, 9 insertions(+), 33 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index 573a042679..2901b8ba28 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -17,8 +17,8 @@ The measure and generating-functional formulation of the Euclidean field axioms. We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity (OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and -clustering and ergodicity (OS4). These are assumptions on a probability measure on -real tempered distributions; no existence or reconstruction theorem is asserted. +ergodicity (OS4). These are assumptions on a probability measure on real tempered distributions; +no existence or reconstruction theorem is asserted. The source conventions are retained: `d` is the total dimension and `2 ≤ d`; positive-time tests have topological support in the open positive-time half-space; @@ -27,24 +27,21 @@ nonnegativity of the real part of the reflected quadratic form. The `p = 2` condition includes convergence of mollified two-point functions away from zero, not merely local integrability of a possibly nonexistent limit. -The source bundles both clustering and ergodicity. We retain this convention without -asserting equivalence between them. Polynomial clustering is supplied separately, as in -the source. Clustering uses the characteristic functional on real tests. Ergodicity and -polynomial clustering use exponentials without a factor of `i`, whereas the characteristic -functional in OS0–OS3 and clustering includes that factor. +OS4 uses exponentials without a factor of `i`, whereas the characteristic functional +in OS0–OS3 includes that factor. This numbering differs from the distributional Osterwalder–Schrader axioms E0–E4. ## ii. Key results -* `GlimmJaffeAxioms`: the bundled Glimm–Jaffe conditions from `SatisfiesAllOS` in `OSforGFF`. +* `GlimmJaffeAxioms`: the five Glimm–Jaffe conditions OS0–OS4, with ergodicity as OS4. * `TwoPointIntegrable`: the explicit mollifier-limit condition at the OS1 endpoint. -* `OS4PolynomialClustering`: the separate polynomial clustering condition from the source. +* `OS4Ergodicity`: convergence of centered time averages in mean square. ## iii. Table of contents - A. Analyticity and regularity - B. Euclidean invariance and reflection positivity -- C. Clustering and ergodicity +- C. Ergodicity - D. Bundled axioms ## iv. References @@ -102,15 +99,7 @@ def OS3ReflectionPositivity (μ : ProbabilityMeasure (FieldConfiguration d)) : P 0 ≤ (∑ i, ∑ j, starRingEnd ℂ (c i) * c j * generatingFunctional μ ((f i).val - reflectedConjugate (f j).val)).re -/-! ## C. Clustering and ergodicity -/ - -/-- OS4 clustering for real tests: the characteristic functional factorizes as -their Euclidean separation tends to infinity, uniformly over translation directions. -/ -def OS4Clustering (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∀ (f g : 𝓢(EuclideanSpacetime d, ℝ)) (ε : ℝ), 0 < ε → - ∃ R : ℝ, 0 < R ∧ ∀ a : EuclideanSpacetime d, R < ‖a‖ → - ‖generatingFunctionalReal μ (f + SchwartzMap.compSubConstCLM ℝ a g) - - generatingFunctionalReal μ f * generatingFunctionalReal μ g‖ < ε +/-! ## C. Ergodicity -/ /-- OS4 ergodicity: centered time averages of finite linear combinations of `exp(⟨ω, f⟩)` converge to zero in mean square. This retains the source's integral @@ -123,19 +112,9 @@ def OS4Ergodicity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := (A (timeTranslation s ω) - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) atTop (𝓝 0) -/-- Polynomial clustering at exponent `α > 0`, supplied separately from the bundled -axioms. The correlations here use `exp(⟨ω, f⟩)`, without the characteristic factor `i`. -/ -def OS4PolynomialClustering (μ : ProbabilityMeasure (FieldConfiguration d)) - (α : ℝ) (_hα : 0 < α) : Prop := - ∀ f g : 𝓢(EuclideanSpacetime d, ℂ), ∃ c : ℝ, 0 ≤ c ∧ ∀ s : ℝ, 0 ≤ s → - ‖(∫ ω, Complex.exp (pairing ω f + pairing (timeTranslation s ω) g) ∂μ.toMeasure) - - (∫ ω, Complex.exp (pairing ω f) ∂μ.toMeasure) * - (∫ ω, Complex.exp (pairing ω g) ∂μ.toMeasure)‖ ≤ c * (1 + s) ^ (-α) - /-! ## D. Bundled axioms -/ -/-- The Glimm–Jaffe conditions bundled as in `SatisfiesAllOS` in `OSforGFF`. -Clustering and ergodicity are both required; polynomial clustering is separate. -/ +/-- The Glimm–Jaffe axioms OS0–OS4, with ergodicity as the OS4 condition. -/ structure GlimmJaffeAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where /-- OS0: entire dependence on finite families of complex tests. -/ analytic : OS0Analyticity μ @@ -145,8 +124,6 @@ structure GlimmJaffeAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Pr euclideanInvariant : OS2EuclideanInvariance μ /-- OS3: reflection positivity for complex positive-time tests and coefficients. -/ reflectionPositive : OS3ReflectionPositivity μ - /-- OS4: clustering under arbitrary large Euclidean translations. -/ - clustering : OS4Clustering μ /-- OS4: mean-square ergodicity under time translation. -/ ergodic : OS4Ergodicity μ diff --git a/scripts/lint/exemptions/spellingWords.txt b/scripts/lint/exemptions/spellingWords.txt index 86e0c2b8a9..1ccc17716b 100644 --- a/scripts/lint/exemptions/spellingWords.txt +++ b/scripts/lint/exemptions/spellingWords.txt @@ -1,7 +1,6 @@ boundedness analyticity Cherkis -clustering cylinder ergodicity functionals From 1b4eae9f728dc75d043142b350434be285d3ecb8 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sun, 15 Nov 2026 16:40:19 -0500 Subject: [PATCH 06/11] feat(TimeAndSpace): add Euclidean coordinates and time reflection Add the time-first continuous linear coordinate equivalence, prove that it preserves spacetime volume, and provide time reflection with its involution law. Co-authored-by: Codex --- Physlib/SpaceAndTime/TimeAndSpace/Basic.lean | 52 ++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean b/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean index 6f855507f5..8ac31389f4 100644 --- a/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean +++ b/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean @@ -21,6 +21,8 @@ The derivative and distribution results are in the namespace `Space` by conventi - `TimeAndSpace d` : Euclidean spacetime as the product of time and space. - `TimeAndSpace.time` : The projection from `TimeAndSpace d` to `Time`. +- `TimeAndSpace.euclideanCoordinates` : Time-first Euclidean coordinates. +- `TimeAndSpace.timeReflection` : Reflection about the chosen time origin. - `TimeAndSpace.space` : The projection from `TimeAndSpace d` to `Space d`. - `distTimeDeriv` : The derivative of a distribution on `Time × Space d` along the temporal coordinate. @@ -107,6 +109,56 @@ lemma dist_space_le (tx ty : TimeAndSpace d) : rw [Prod.dist_eq] exact le_max_right _ _ +/-- Euclidean coordinates with time first and the spatial coordinates following it. -/ +noncomputable def euclideanCoordinates : TimeAndSpace d ≃L[ℝ] EuclideanSpace ℝ (Fin (d + 1)) := + LinearEquiv.toContinuousLinearEquiv + { toFun := fun tx => WithLp.toLp 2 (Fin.cons tx.1.val tx.2.val) + invFun := fun x => (⟨x 0⟩, ⟨fun i => x i.succ⟩) + left_inv := by rintro ⟨⟨t⟩, ⟨x⟩⟩; rfl + right_inv := by + intro x + ext i + exact Fin.cases rfl (fun _ => rfl) i + map_add' := by + intro x y + ext i + exact Fin.cases rfl (fun _ => rfl) i + map_smul' := by + intro r x + ext i + exact Fin.cases rfl (fun _ => rfl) i } + +open MeasureTheory in +/-- The time-first Euclidean coordinates preserve spacetime volume. -/ +lemma euclideanCoordinates_measurePreserving : + MeasurePreserving (euclideanCoordinates (d := d)) volume volume := by + have hs : MeasurePreserving (fun x : Space d => x.val) volume volume := by + convert (PiLp.volume_preserving_ofLp (Fin d)).comp + ((Space.basis (d := d)).measurePreserving_repr) using 1 + ext x i + exact (Space.basis_repr_apply x i).symm + have hp := Time.val_measurePreserving.prod hs + have hc := (volume_preserving_piFinSuccAbove (fun _ : Fin (d + 1) => ℝ) 0).symm + have h := (PiLp.volume_preserving_toLp (Fin (d + 1))).comp (hc.comp hp) + convert h using 1 + ext tx i + exact Fin.cases rfl (fun _ => rfl) i + +/-- Time reflection about the chosen time origin, fixing all spatial coordinates. -/ +noncomputable def timeReflection : TimeAndSpace d ≃L[ℝ] TimeAndSpace d := + (ContinuousLinearEquiv.neg ℝ).prodCongr (ContinuousLinearEquiv.refl ℝ (Space d)) + +/-- Time reflection reverses time and leaves space unchanged. -/ +@[simp] +lemma timeReflection_apply (tx : TimeAndSpace d) : + timeReflection tx = (-tx.1, tx.2) := rfl + +/-- Applying time reflection twice returns the original spacetime point. -/ +@[simp] +lemma timeReflection_involutive (tx : TimeAndSpace d) : + timeReflection (timeReflection tx) = tx := by + simp only [timeReflection_apply, neg_neg] + end TimeAndSpace namespace Space From 7283fe1cd5c596c3953871a283bc4064b750459a Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sun, 15 Nov 2026 16:40:19 -0500 Subject: [PATCH 07/11] refactor(QFT): express Glimm-Jaffe axioms on TimeAndSpace Use the shared spacetime coordinates and FieldConfiguration namespace while preserving full Euclidean invariance, dimension assumptions, and the original Schwinger and mollifier formulas. Prove transported bumps retain integral one. Consolidate the copyright notices and document the Chapter 6 source in Glimm and Jaffe, Quantum Physics. Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 37 ++-- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 187 ++++++++++--------- 2 files changed, 122 insertions(+), 102 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index 2901b8ba28..ab22a51c37 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -1,6 +1,6 @@ /- -Copyright (c) 2025 Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. All rights reserved. -Copyright (c) 2026 Sergey A. Cherkis. All rights reserved. +Copyright (c) 2026 Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. +All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim -/ @@ -15,12 +15,18 @@ The measure and generating-functional formulation of the Euclidean field axioms. ## i. Overview +This is a formalization of the Glimm–Jaffe variation of the Osterwalder–Schrader axioms, +as presented in Glimm and Jaffe, *Quantum Physics*, Chapter 6. [ref: glimm1987quantum] + We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity (OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and ergodicity (OS4). These are assumptions on a probability measure on real tempered distributions; no existence or reconstruction theorem is asserted. -The source conventions are retained: `d` is the total dimension and `2 ≤ d`; +Here `d` counts spatial dimensions, so the source total dimension is `d + 1`. +Reflection positivity, ergodicity and the bundle assume `1 ≤ d`, retaining the source +minimum of two total dimensions. +The remaining source conventions are retained: positive-time tests have topological support in the open positive-time half-space; OS1 bounds the sum of the integrals of `‖f‖` and `‖f‖^p`; and OS3 asserts nonnegativity of the real part of the reflected quadratic form. The `p = 2` @@ -46,7 +52,7 @@ This numbering differs from the distributional Osterwalder–Schrader axioms E0 ## iv. References -* Glimm and Jaffe, *Quantum Physics*. [ref: glimm1987quantum] +* Glimm and Jaffe, *Quantum Physics*, Chapter 6. [ref: glimm1987quantum] * Cherkis et al., *OSforGFF*, `OS/Axioms.lean`. [ref: osforgff] -/ @@ -58,20 +64,22 @@ open scoped SchwartzMap Topology namespace GlimmJaffe -variable {d : ℕ} [Fact (2 ≤ d)] +open FieldConfiguration + +variable {d : ℕ} /-! ## A. Analyticity and regularity -/ /-- OS0: the characteristic functional is entire on every finite-dimensional complex family of Schwartz tests. -/ def OS0Analyticity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∀ (n : ℕ) (J : Fin n → 𝓢(EuclideanSpacetime d, ℂ)), + ∀ (n : ℕ) (J : Fin n → 𝓢(TimeAndSpace d, ℂ)), AnalyticOn ℂ (fun z : Fin n → ℂ => generatingFunctional μ (∑ i, z i • J i)) Set.univ /-- The endpoint condition for OS1: mollified second moments converge at every nonzero separation to a locally integrable function. No limit is required at coincidence. -/ def TwoPointIntegrable (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∃ K : EuclideanSpacetime d → ℝ, LocallyIntegrable K volume ∧ + ∃ K : TimeAndSpace d → ℝ, LocallyIntegrable K volume ∧ ∀ x, x ≠ 0 → Tendsto (fun n => SmearedTwoPointFunction μ (standardBumpSequence (n + 1) (Nat.succ_ne_zero n)) x) atTop (𝓝 (K x)) @@ -80,7 +88,7 @@ def TwoPointIntegrable (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop : for some `1 ≤ p ≤ 2`, with the additional two-point condition when `p = 2`. -/ def OS1Regularity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := ∃ p c : ℝ, 1 ≤ p ∧ p ≤ 2 ∧ 0 < c ∧ - (∀ f : 𝓢(EuclideanSpacetime d, ℂ), + (∀ f : 𝓢(TimeAndSpace d, ℂ), ‖generatingFunctional μ f‖ ≤ Real.exp (c * ((∫ x, ‖f x‖) + ∫ x, ‖f x‖ ^ p))) ∧ (p = 2 → TwoPointIntegrable μ) @@ -89,12 +97,13 @@ def OS1Regularity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := /-- OS2: invariance of the characteristic functional under the full Euclidean group. -/ def OS2EuclideanInvariance (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∀ (g : EuclideanGroup d) (f : 𝓢(EuclideanSpacetime d, ℂ)), + ∀ (g : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace d, ℂ)), generatingFunctional μ f = generatingFunctional μ (euclideanAction g f) /-- OS3 in the source's complex formulation: the real part of every reflected quadratic form is nonnegative. Reflection includes complex conjugation of the test. -/ -def OS3ReflectionPositivity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := +def OS3ReflectionPositivity [Fact (1 ≤ d)] + (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := ∀ (n : ℕ) (f : Fin n → PositiveTimeTestFunction d) (c : Fin n → ℂ), 0 ≤ (∑ i, ∑ j, starRingEnd ℂ (c i) * c j * generatingFunctional μ ((f i).val - reflectedConjugate (f j).val)).re @@ -104,8 +113,9 @@ def OS3ReflectionPositivity (μ : ProbabilityMeasure (FieldConfiguration d)) : P /-- OS4 ergodicity: centered time averages of finite linear combinations of `exp(⟨ω, f⟩)` converge to zero in mean square. This retains the source's integral formulation, with the centering inside the time integral. -/ -def OS4Ergodicity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := - ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(EuclideanSpacetime d, ℂ)), +def OS4Ergodicity [Fact (1 ≤ d)] + (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(TimeAndSpace d, ℂ)), let A : FieldConfiguration d → ℂ := fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) Tendsto (fun T : ℝ => ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, @@ -115,7 +125,8 @@ def OS4Ergodicity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := /-! ## D. Bundled axioms -/ /-- The Glimm–Jaffe axioms OS0–OS4, with ergodicity as the OS4 condition. -/ -structure GlimmJaffeAxioms (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where +structure GlimmJaffeAxioms [Fact (1 ≤ d)] + (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop where /-- OS0: entire dependence on finite families of complex tests. -/ analytic : OS0Analyticity μ /-- OS1: the exponential bound and endpoint two-point condition. -/ diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index 2d151cd3d9..0cc5716d18 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -1,6 +1,6 @@ /- -Copyright (c) 2025 Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. All rights reserved. -Copyright (c) 2026 Sergey A. Cherkis. All rights reserved. +Copyright (c) 2026 Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim. +All rights reserved. Released under Apache 2.0 license as described in the file LICENSE. Authors: Sergey A. Cherkis, Michael R. Douglas, Sarah Hoback, Anna Mei, Ron Nissim -/ @@ -15,6 +15,7 @@ public import Mathlib.Analysis.LocallyConvex.WeakDual public import Mathlib.Analysis.Normed.Lp.MeasurableSpace public import Mathlib.MeasureTheory.Measure.ProbabilityMeasure public import Physlib.SpaceAndTime.Space.EuclideanGroup.AffineGroup +public import Physlib.SpaceAndTime.TimeAndSpace.Basic /-! # Glimm–Jaffe Euclidean fields @@ -23,20 +24,33 @@ Test functions, field configurations and generating functionals for a real scala ## i. Overview -This is the measure-based setup used by `OSforGFF`, adapted to Mathlib and Physlib. -The parameter `d` counts all Euclidean spacetime coordinates, with coordinate zero -designated as time. Field configurations are real tempered distributions with their -weak dual topology and cylinder sigma algebra. Their pairing with complex Schwartz -functions is extended complex linearly. - -Translations use Mathlib's Schwartz pullback; Euclidean transformations use Physlib's -full Euclidean group, including reflections. The reflected conjugate is a named map, -so it does not change the pointwise `Star` instance on Schwartz functions. +This is the measure-based formulation of a real scalar Euclidean quantum field. +A field configuration is a tempered distribution `ω`, so the basic observable is its +evaluation `ω f` on a real Schwartz test function `f`, rather than a value at a point. +A probability measure on these configurations specifies the field statistics: +Schwinger functions are expectations of products of field evaluations, and the +generating functional is the expectation of `exp(i ⟨ω, f⟩)`. The Glimm–Jaffe axioms +in the companion file impose analyticity, growth bounds, Euclidean invariance, +reflection positivity and ergodicity on this measure. This setup supplies the +Euclidean data for reconstruction; this file proves no reconstruction theorem. + +The parameter `d` counts spatial dimensions. Spacetime is Physlib's +`TimeAndSpace d = Time × Space d`, with the standard origins used by its real +vector-space instances. Thus the source's total dimension is `d + 1`. +Field configurations carry the weak dual topology and the cylinder sigma algebra; +their pairing with complex Schwartz functions is extended complex linearly. + +The full `EuclideanGroup (d + 1)` action is transported through time-first Euclidean +coordinates, so it includes transformations mixing time and space. The normalized +bumps are constructed in those Euclidean coordinates and pulled back to +`TimeAndSpace d`, preserving the source's Euclidean mollifier sequence. +The reflected conjugate combines complex conjugation with time reflection. ## ii. Key results * `FieldConfiguration`: real tempered distributions with the cylinder sigma algebra. -* `generatingFunctional` and `generatingFunctionalReal`: characteristic functionals. +* `FieldConfiguration.generatingFunctional`: the complex characteristic functional. +* `FieldConfiguration.generatingFunctionalReal`: its restriction to real tests. * `reflectedConjugate`: conjugation combined with Euclidean time reflection. * `SmearedTwoPointFunction`: the two-point function smeared with an arbitrary normalized bump. @@ -64,11 +78,10 @@ namespace GlimmJaffe /-! ## A. Field configurations and generating functionals -/ -/-- Euclidean spacetime with `d` total coordinates; coordinate zero is time. -/ -abbrev EuclideanSpacetime (d : ℕ) := EuclideanSpace ℝ (Fin d) - /-- Real scalar field configurations, with the weak dual topology on tempered distributions. -/ -abbrev FieldConfiguration (d : ℕ) := WeakDual ℝ (𝓢(EuclideanSpacetime d, ℝ)) +abbrev FieldConfiguration (d : ℕ) := WeakDual ℝ (𝓢(TimeAndSpace d, ℝ)) + +namespace FieldConfiguration /-- The cylinder sigma algebra generated by all real Schwartz evaluations. -/ instance fieldConfigurationMeasurableSpace (d : ℕ) : MeasurableSpace (FieldConfiguration d) := @@ -77,136 +90,132 @@ instance fieldConfigurationMeasurableSpace (d : ℕ) : MeasurableSpace (FieldCon variable {d : ℕ} /-- The complex-linear extension of the pairing of a real field with a Schwartz test. -/ -def pairing (ω : FieldConfiguration d) (f : 𝓢(EuclideanSpacetime d, ℂ)) : ℂ := +def pairing (ω : FieldConfiguration d) (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) + Complex.I * (ω (SchwartzMap.postcompCLM Complex.imCLM f) : ℂ) /-- The characteristic functional `Z[f] = ∫ exp(i ⟨ω, f⟩) dμ` on complex tests. -/ def generatingFunctional (μ : ProbabilityMeasure (FieldConfiguration d)) - (f : 𝓢(EuclideanSpacetime d, ℂ)) : ℂ := + (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := ∫ ω, Complex.exp (Complex.I * pairing ω f) ∂μ.toMeasure /-- The characteristic functional restricted to real Schwartz tests. -/ def generatingFunctionalReal (μ : ProbabilityMeasure (FieldConfiguration d)) - (f : 𝓢(EuclideanSpacetime d, ℝ)) : ℂ := + (f : 𝓢(TimeAndSpace d, ℝ)) : ℂ := ∫ ω, Complex.exp (Complex.I * (ω f : ℂ)) ∂μ.toMeasure +end FieldConfiguration + +open FieldConfiguration + +variable {d : ℕ} + /-! ## B. Euclidean symmetries and positive time -/ -/-- Pullback of a complex test by the inverse of a full Euclidean transformation. -/ -def euclideanAction (g : EuclideanGroup d) : - 𝓢(EuclideanSpacetime d, ℂ) →L[ℂ] 𝓢(EuclideanSpacetime d, ℂ) := - let e := EuclideanGroup.toAffineIsometryHom g⁻¹ - SchwartzMap.compCLMOfAntilipschitz ℂ (K := 1) - (g := fun x => e.linearIsometryEquiv x + e 0) - (e.linearIsometryEquiv.toContinuousLinearMap.hasTemperateGrowth.add (by fun_prop)) +/-- Pullback by a full Euclidean transformation, including rotations mixing time and space. -/ +def euclideanAction (g : EuclideanGroup (d + 1)) : + 𝓢(TimeAndSpace d, ℂ) →L[ℂ] 𝓢(TimeAndSpace d, ℂ) := + let e := TimeAndSpace.euclideanCoordinates (d := d) + let a := EuclideanGroup.toAffineIsometryHom g⁻¹ + let pullback := SchwartzMap.compCLMOfAntilipschitz ℂ (K := 1) + (g := fun x => a.linearIsometryEquiv x + a 0) + (a.linearIsometryEquiv.toContinuousLinearMap.hasTemperateGrowth.add (by fun_prop)) (by - have he : (fun x => e.linearIsometryEquiv x + e 0) = e := by + have ha : (fun x => a.linearIsometryEquiv x + a 0) = a := by funext x - simpa only [vadd_eq_add, add_zero] using (e.map_vadd 0 x).symm - rw [he] - exact e.antilipschitzWith) + simpa only [vadd_eq_add, add_zero] using (a.map_vadd 0 x).symm + rw [ha] + exact a.antilipschitzWith) + (SchwartzMap.compCLMOfContinuousLinearEquiv ℂ e).comp + (pullback.comp (SchwartzMap.compCLMOfContinuousLinearEquiv ℂ e.symm)) -/-- The Euclidean action is pullback by the inverse affine isometry. -/ +/-- The full Euclidean pullback expressed in time-first coordinates. -/ @[simp] -lemma euclideanAction_apply (g : EuclideanGroup d) (f : 𝓢(EuclideanSpacetime d, ℂ)) - (x : EuclideanSpacetime d) : - euclideanAction g f x = f (EuclideanGroup.toAffineIsometryHom g⁻¹ x) := by - change f (_ + _) = _ - congr 1 - simpa only [vadd_eq_add, add_zero] using - ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 x).symm - -variable [Fact (2 ≤ d)] - -/-- The distinguished Euclidean time coordinate. -/ -def timeIndex : Fin d := ⟨0, by have := Fact.out (p := 2 ≤ d); omega⟩ - -/-- Reflection of the time coordinate, as a continuous linear equivalence. -/ -def timeReflection : EuclideanSpacetime d ≃L[ℝ] EuclideanSpacetime d := - (EuclideanSpace.equiv (Fin d) ℝ).trans - ((ContinuousLinearEquiv.piCongrRight fun i : Fin d => - if i = timeIndex then ContinuousLinearEquiv.neg ℝ else ContinuousLinearEquiv.refl ℝ ℝ).trans - (EuclideanSpace.equiv (Fin d) ℝ).symm) - -/-- Time reflection negates the time coordinate and fixes every spatial coordinate. -/ -lemma timeReflection_apply (x : EuclideanSpacetime d) (i : Fin d) : - timeReflection x i = if i = timeIndex then -x i else x i := by - change (if i = timeIndex then ContinuousLinearEquiv.neg ℝ else - ContinuousLinearEquiv.refl ℝ ℝ) (x i) = _ - split <;> rfl +lemma euclideanAction_apply (g : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace d, ℂ)) + (x : TimeAndSpace d) : + euclideanAction g f x = f (TimeAndSpace.euclideanCoordinates.symm + (EuclideanGroup.toAffineIsometryHom g⁻¹ (TimeAndSpace.euclideanCoordinates x))) := by + change f (TimeAndSpace.euclideanCoordinates.symm (_ + _)) = _ + congr 2 + simpa only [ContinuousLinearEquiv.coe_coe, vadd_eq_add, add_zero] using + ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 + (TimeAndSpace.euclideanCoordinates x)).symm /-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. -/ -def reflectedConjugate (f : 𝓢(EuclideanSpacetime d, ℂ)) : 𝓢(EuclideanSpacetime d, ℂ) := +def reflectedConjugate [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, ℂ)) : + 𝓢(TimeAndSpace d, ℂ) := SchwartzMap.postcompCLM Complex.conjCLE.toContinuousLinearMap - (SchwartzMap.compCLMOfContinuousLinearEquiv ℝ timeReflection f) + (SchwartzMap.compCLMOfContinuousLinearEquiv ℝ TimeAndSpace.timeReflection f) /-- The reflected conjugate includes both time reflection and complex conjugation. -/ @[simp] -lemma reflectedConjugate_apply (f : 𝓢(EuclideanSpacetime d, ℂ)) - (x : EuclideanSpacetime d) : - reflectedConjugate f x = starRingEnd ℂ (f (timeReflection x)) := rfl +lemma reflectedConjugate_apply [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, ℂ)) + (x : TimeAndSpace d) : + reflectedConjugate f x = starRingEnd ℂ (f (TimeAndSpace.timeReflection x)) := rfl /-- Applying the reflected conjugation twice recovers the original test. -/ @[simp] -lemma reflectedConjugate_involutive (f : 𝓢(EuclideanSpacetime d, ℂ)) : +lemma reflectedConjugate_involutive [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, ℂ)) : reflectedConjugate (reflectedConjugate f) = f := by ext x - simp only [reflectedConjugate_apply, starRingEnd_self_apply] - congr 1 - ext i - simp only [timeReflection_apply] - split <;> simp_all + simp only [reflectedConjugate_apply, starRingEnd_self_apply, + TimeAndSpace.timeReflection_involutive] /-- Complex Schwartz functions whose topological support lies strictly at positive time. This retains the support convention of `OSforGFF`. -/ -abbrev PositiveTimeTestFunction (d : ℕ) [Fact (2 ≤ d)] := - {f : 𝓢(EuclideanSpacetime d, ℂ) | tsupport f ⊆ {x | 0 < x timeIndex}} +abbrev PositiveTimeTestFunction (d : ℕ) [Fact (1 ≤ d)] := + {f : 𝓢(TimeAndSpace d, ℂ) | tsupport f ⊆ {x | 0 < x.1}} -/-- Time translation of a field by duality: `(T_s ω)(f) = ω(x ↦ f(x - s e₀))`. -The corresponding source convention on test functions is `T_s f(x) = f(x + s e₀)`. -/ -def timeTranslation (s : ℝ) (ω : FieldConfiguration d) : FieldConfiguration d := - ω.comp (SchwartzMap.compSubConstCLM ℝ (EuclideanSpace.single timeIndex s)) +/-- Time translation of a field by duality: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. +The corresponding source convention on test functions is `T_s f(t, x) = f(t + s, x)`. -/ +def timeTranslation [Fact (1 ≤ d)] (s : ℝ) (ω : FieldConfiguration d) : + FieldConfiguration d := + ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0)) /-! ## C. Smeared two-point functions -/ -omit [Fact (2 ≤ d)] in /-- The real `n`-point Schwinger function, the expectation of the product of field evaluations. -/ def SchwingerFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) (n : ℕ) - (f : Fin n → 𝓢(EuclideanSpacetime d, ℝ)) : ℝ := + (f : Fin n → 𝓢(TimeAndSpace d, ℝ)) : ℝ := ∫ ω, (∏ i, ω (f i)) ∂dμ_config.toMeasure -omit [Fact (2 ≤ d)] in /-- The real two-point Schwinger function evaluated on two Schwartz tests. -/ def SchwingerFunction₂ (dμ_config : ProbabilityMeasure (FieldConfiguration d)) - (f g : 𝓢(EuclideanSpacetime d, ℝ)) : ℝ := + (f g : 𝓢(TimeAndSpace d, ℝ)) : ℝ := SchwingerFunction dμ_config 2 ![f, g] -omit [Fact (2 ≤ d)] in /-- Convert a smooth bump centered at zero to a real Schwartz test with integral one. -/ -def bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpacetime d)) : - 𝓢(EuclideanSpacetime d, ℝ) := - (φ.hasCompactSupport_normed (μ := volume)).toSchwartzMap φ.contDiff_normed +def bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) : + 𝓢(TimeAndSpace d, ℝ) := + SchwartzMap.compCLMOfContinuousLinearEquiv ℝ TimeAndSpace.euclideanCoordinates + ((φ.hasCompactSupport_normed (μ := volume)).toSchwartzMap φ.contDiff_normed) + +/-- The Euclidean bump retains integral one after transport to time and space coordinates. -/ +@[simp] +lemma integral_bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) : + ∫ x, bumpToSchwartz φ x = 1 := by + change ∫ x, φ.normed volume (TimeAndSpace.euclideanCoordinates x) = 1 + rw [TimeAndSpace.euclideanCoordinates_measurePreserving.integral_comp + TimeAndSpace.euclideanCoordinates.toHomeomorph.measurableEmbedding] + exact φ.integral_normed -omit [Fact (2 ≤ d)] in /-- Translate a real Schwartz test by `a`, with value `f (x - a)` at `x`. -/ -def translateSchwartz (f : 𝓢(EuclideanSpacetime d, ℝ)) (a : EuclideanSpacetime d) : - 𝓢(EuclideanSpacetime d, ℝ) := +def translateSchwartz (f : 𝓢(TimeAndSpace d, ℝ)) (a : TimeAndSpace d) : + 𝓢(TimeAndSpace d, ℝ) := SchwartzMap.compSubConstCLM ℝ a f -omit [Fact (2 ≤ d)] in /-- The two-point Schwinger function smeared at `x` and zero with an arbitrary normalized bump. This follows `SmearedTwoPointFunction` in `OSforGFF`, with the bump supplied independently of the standard sequence used in the OS1 endpoint condition. -/ def SmearedTwoPointFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) - (φ : ContDiffBump (0 : EuclideanSpacetime d)) (x : EuclideanSpacetime d) : ℝ := + (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) (x : TimeAndSpace d) : ℝ := SchwingerFunction₂ dμ_config (translateSchwartz (bumpToSchwartz φ) x) (bumpToSchwartz φ) -omit [Fact (2 ≤ d)] in /-- The standard bump sequence from `OSforGFF`, with outer radius `1 / n` for nonzero `n`. -/ -def standardBumpSequence (n : ℕ) (hn : n ≠ 0) : ContDiffBump (0 : EuclideanSpacetime d) where +def standardBumpSequence (n : ℕ) (hn : n ≠ 0) : + ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1))) where rIn := 1 / (2 * n) rOut := 1 / n rIn_pos := by positivity From 5426b3f7dd7574b89e4347be604555f15b34fbc1 Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sun, 15 Nov 2026 16:46:12 -0500 Subject: [PATCH 08/11] fix(QFT): document intentional dimension restrictions for linters Retain the original Glimm-Jaffe domain with narrow unused-argument exemptions. Remove a redundant simp attribute and two redundant imports without changing executable bodies. Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 14 +++++++++----- Physlib/SpaceAndTime/TimeAndSpace/Basic.lean | 1 - 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index 0cc5716d18..3df45644ab 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -10,8 +10,6 @@ module -- their private transitive imports through Schwartz space do not expose the instances. public import Mathlib.Analysis.Calculus.BumpFunction.InnerProduct public import Mathlib.Analysis.Calculus.BumpFunction.Normed -public import Mathlib.Analysis.Distribution.SchwartzSpace.Basic -public import Mathlib.Analysis.LocallyConvex.WeakDual public import Mathlib.Analysis.Normed.Lp.MeasurableSpace public import Mathlib.MeasureTheory.Measure.ProbabilityMeasure public import Physlib.SpaceAndTime.Space.EuclideanGroup.AffineGroup @@ -141,7 +139,9 @@ lemma euclideanAction_apply (g : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 (TimeAndSpace.euclideanCoordinates x)).symm -/-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. -/ +/-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. +The dimension restriction retains the source's domain of at least two total dimensions. -/ +@[nolint unusedArguments] def reflectedConjugate [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, ℂ)) : 𝓢(TimeAndSpace d, ℂ) := SchwartzMap.postcompCLM Complex.conjCLE.toContinuousLinearMap @@ -162,12 +162,16 @@ lemma reflectedConjugate_involutive [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, TimeAndSpace.timeReflection_involutive] /-- Complex Schwartz functions whose topological support lies strictly at positive time. -This retains the support convention of `OSforGFF`. -/ +This retains the support convention of `OSforGFF` and its domain of at least +two total dimensions. -/ +@[nolint unusedArguments] abbrev PositiveTimeTestFunction (d : ℕ) [Fact (1 ≤ d)] := {f : 𝓢(TimeAndSpace d, ℂ) | tsupport f ⊆ {x | 0 < x.1}} /-- Time translation of a field by duality: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. -The corresponding source convention on test functions is `T_s f(t, x) = f(t + s, x)`. -/ +The corresponding source convention on test functions is `T_s f(t, x) = f(t + s, x)`. +The dimension restriction retains the source's domain of at least two total dimensions. -/ +@[nolint unusedArguments] def timeTranslation [Fact (1 ≤ d)] (s : ℝ) (ω : FieldConfiguration d) : FieldConfiguration d := ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0)) diff --git a/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean b/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean index 8ac31389f4..0a7bcb90d2 100644 --- a/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean +++ b/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean @@ -154,7 +154,6 @@ lemma timeReflection_apply (tx : TimeAndSpace d) : timeReflection tx = (-tx.1, tx.2) := rfl /-- Applying time reflection twice returns the original spacetime point. -/ -@[simp] lemma timeReflection_involutive (tx : TimeAndSpace d) : timeReflection (timeReflection tx) = tx := by simp only [timeReflection_apply, neg_neg] From c5e760ca1d77c0744cabd6ed59053c6ba46c0ece Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Sun, 15 Nov 2026 23:00:07 -0500 Subject: [PATCH 09/11] minor comment editing --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 10 ++-------- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 10 +++++----- 2 files changed, 7 insertions(+), 13 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index ab22a51c37..25531b3e69 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -17,21 +17,15 @@ The measure and generating-functional formulation of the Euclidean field axioms. This is a formalization of the Glimm–Jaffe variation of the Osterwalder–Schrader axioms, as presented in Glimm and Jaffe, *Quantum Physics*, Chapter 6. [ref: glimm1987quantum] +This formalism is on the generating functional, while the original OS axioms are on the Schwinger functions. We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity (OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and -ergodicity (OS4). These are assumptions on a probability measure on real tempered distributions; -no existence or reconstruction theorem is asserted. +ergodicity (OS4). Here `d` counts spatial dimensions, so the source total dimension is `d + 1`. Reflection positivity, ergodicity and the bundle assume `1 ≤ d`, retaining the source minimum of two total dimensions. -The remaining source conventions are retained: -positive-time tests have topological support in the open positive-time half-space; -OS1 bounds the sum of the integrals of `‖f‖` and `‖f‖^p`; and OS3 asserts -nonnegativity of the real part of the reflected quadratic form. The `p = 2` -condition includes convergence of mollified two-point functions away from zero, -not merely local integrability of a possibly nonexistent limit. OS4 uses exponentials without a factor of `i`, whereas the characteristic functional in OS0–OS3 includes that factor. diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index 3df45644ab..aaf859f708 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -24,19 +24,19 @@ Test functions, field configurations and generating functionals for a real scala This is the measure-based formulation of a real scalar Euclidean quantum field. A field configuration is a tempered distribution `ω`, so the basic observable is its -evaluation `ω f` on a real Schwartz test function `f`, rather than a value at a point. -A probability measure on these configurations specifies the field statistics: +evaluation `ω f` on a real Schwartz test function `f`. +A probability measure on these configurations specifies the field statistics, in a way that Schwinger functions are expectations of products of field evaluations, and the generating functional is the expectation of `exp(i ⟨ω, f⟩)`. The Glimm–Jaffe axioms in the companion file impose analyticity, growth bounds, Euclidean invariance, reflection positivity and ergodicity on this measure. This setup supplies the -Euclidean data for reconstruction; this file proves no reconstruction theorem. +Euclidean data for reconstruction. The parameter `d` counts spatial dimensions. Spacetime is Physlib's `TimeAndSpace d = Time × Space d`, with the standard origins used by its real vector-space instances. Thus the source's total dimension is `d + 1`. -Field configurations carry the weak dual topology and the cylinder sigma algebra; -their pairing with complex Schwartz functions is extended complex linearly. +Field configurations carry the weak dual topology and the cylinder sigma algebra. +Their pairing with complex Schwartz functions is extended complex linearly. The full `EuclideanGroup (d + 1)` action is transported through time-first Euclidean coordinates, so it includes transformations mixing time and space. The normalized From 0410daca9314066eca9f4ce73e75df953d74f5ba Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Mon, 16 Nov 2026 00:49:11 -0500 Subject: [PATCH 10/11] refactor(QFT): use complex translations with real field measures Reuse Mathlib conversions for real bumps and field configurations. Add the Euclidean action on complex distributions and prove its group laws and translation convention. Prove that the smeared two-point function and OS4 retain their original real formulations. Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 29 +++- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 136 +++++++++++++++++-- 2 files changed, 150 insertions(+), 15 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index 25531b3e69..56978f1fd7 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -17,7 +17,8 @@ The measure and generating-functional formulation of the Euclidean field axioms. This is a formalization of the Glimm–Jaffe variation of the Osterwalder–Schrader axioms, as presented in Glimm and Jaffe, *Quantum Physics*, Chapter 6. [ref: glimm1987quantum] -This formalism is on the generating functional, while the original OS axioms are on the Schwinger functions. +This formalism is on the generating functional, while the original OS axioms are on +the Schwinger functions. We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity (OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and @@ -29,6 +30,9 @@ minimum of two total dimensions. OS4 uses exponentials without a factor of `i`, whereas the characteristic functional in OS0–OS3 includes that factor. +Its observables act on the complex extensions of real configurations, using Mathlib's +`WeakDual.extendRCLikeL` to apply complex time translation. The measure remains on +`FieldConfiguration d`, and this gives the same time averages as real field translation. This numbering differs from the distributional Osterwalder–Schrader axioms E0–E4. ## ii. Key results @@ -110,12 +114,31 @@ formulation, with the centering inside the time integral. -/ def OS4Ergodicity [Fact (1 ≤ d)] (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(TimeAndSpace d, ℂ)), - let A : FieldConfiguration d → ℂ := fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) + let A : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) → ℂ := + fun η => ∑ j, z j * Complex.exp (η (f j)) Tendsto (fun T : ℝ => ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, - (A (timeTranslation s ω) - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) + (A (timeTranslation s (WeakDual.extendRCLikeL (𝕜 := ℂ) + (ω.comp (SchwartzMap.postcompCLM Complex.reCLM)))) - + ∫ ω', A (WeakDual.extendRCLikeL (𝕜 := ℂ) + (ω'.comp (SchwartzMap.postcompCLM Complex.reCLM))) ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) atTop (𝓝 0) +/-- Extending real configurations before translation preserves the original real form of OS4. -/ +lemma OS4Ergodicity_iff_real [Fact (1 ≤ d)] + (μ : ProbabilityMeasure (FieldConfiguration d)) : + OS4Ergodicity μ ↔ + ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(TimeAndSpace d, ℂ)), + let A : FieldConfiguration d → ℂ := + fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) + Tendsto (fun T : ℝ => + ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, + (A (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) - + ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) + atTop (𝓝 0) := by + unfold OS4Ergodicity + simp only [timeTranslation_extendRCLikeL_apply_eq_pairing, extendRCLikeL_apply_eq_pairing] + /-! ## D. Bundled axioms -/ /-- The Glimm–Jaffe axioms OS0–OS4, with ergodicity as the OS4 condition. -/ diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index aaf859f708..5a07d3c006 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -11,6 +11,7 @@ module public import Mathlib.Analysis.Calculus.BumpFunction.InnerProduct public import Mathlib.Analysis.Calculus.BumpFunction.Normed public import Mathlib.Analysis.Normed.Lp.MeasurableSpace +public import Mathlib.Analysis.Normed.Module.WeakDual public import Mathlib.MeasureTheory.Measure.ProbabilityMeasure public import Physlib.SpaceAndTime.Space.EuclideanGroup.AffineGroup public import Physlib.SpaceAndTime.TimeAndSpace.Basic @@ -18,11 +19,11 @@ public import Physlib.SpaceAndTime.TimeAndSpace.Basic /-! # Glimm–Jaffe Euclidean fields -Test functions, field configurations and generating functionals for a real scalar field. +Test functions, field configurations and generating functionals for Euclidean fields. ## i. Overview -This is the measure-based formulation of a real scalar Euclidean quantum field. +This is the measure-based formulation of a scalar Euclidean quantum field. A field configuration is a tempered distribution `ω`, so the basic observable is its evaluation `ω f` on a real Schwartz test function `f`. A probability measure on these configurations specifies the field statistics, in a way that @@ -37,11 +38,16 @@ The parameter `d` counts spatial dimensions. Spacetime is Physlib's vector-space instances. Thus the source's total dimension is `d + 1`. Field configurations carry the weak dual topology and the cylinder sigma algebra. Their pairing with complex Schwartz functions is extended complex linearly. +The measure remains on these real configurations. Euclidean transformations and time +translation also act on complex distributions; Mathlib's `WeakDual.extendRCLikeL` +identifies the complex extension of a real configuration with its existing pairing. The full `EuclideanGroup (d + 1)` action is transported through time-first Euclidean coordinates, so it includes transformations mixing time and space. The normalized bumps are constructed in those Euclidean coordinates and pulled back to `TimeAndSpace d`, preserving the source's Euclidean mollifier sequence. +Translation acts on complex tests. Real bumps are embedded with `Complex.ofRealCLM`, +and the real part of the translated bump recovers the original real Schwartz test. The reflected conjugate combines complex conjugation with time reflection. ## ii. Key results @@ -50,6 +56,7 @@ The reflected conjugate combines complex conjugation with time reflection. * `FieldConfiguration.generatingFunctional`: the complex characteristic functional. * `FieldConfiguration.generatingFunctionalReal`: its restriction to real tests. * `reflectedConjugate`: conjugation combined with Euclidean time reflection. +* `euclideanFieldAction`: the Euclidean action on complex distributions by duality. * `SmearedTwoPointFunction`: the two-point function smeared with an arbitrary normalized bump. ## iii. Table of contents @@ -92,6 +99,19 @@ def pairing (ω : FieldConfiguration d) (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) + Complex.I * (ω (SchwartzMap.postcompCLM Complex.imCLM f) : ℂ) +/-- Mathlib's complex extension of a configuration evaluates as the field pairing. -/ +lemma extendRCLikeL_apply_eq_pairing (ω : FieldConfiguration d) + (f : 𝓢(TimeAndSpace d, ℂ)) : + WeakDual.extendRCLikeL (𝕜 := ℂ) + (ω.comp (SchwartzMap.postcompCLM Complex.reCLM)) f = pairing ω f := by + have h : SchwartzMap.postcompCLM Complex.reCLM (Complex.I • f) = + -SchwartzMap.postcompCLM Complex.imCLM f := by + ext x + simp [Complex.mul_re] + change (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) - + Complex.I * (ω (SchwartzMap.postcompCLM Complex.reCLM (Complex.I • f)) : ℂ) = _ + simp [pairing, h] + /-- The characteristic functional `Z[f] = ∫ exp(i ⟨ω, f⟩) dμ` on complex tests. -/ def generatingFunctional (μ : ProbabilityMeasure (FieldConfiguration d)) (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := @@ -139,6 +159,55 @@ lemma euclideanAction_apply (g : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 (TimeAndSpace.euclideanCoordinates x)).symm +/-- The identity Euclidean transformation fixes each test function. -/ +@[simp] +lemma euclideanAction_one (f : 𝓢(TimeAndSpace d, ℂ)) : euclideanAction 1 f = f := by + ext x + simp [euclideanAction_apply] + +/-- Euclidean pullbacks give a left action on test functions. -/ +lemma euclideanAction_mul (g h : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace d, ℂ)) : + euclideanAction (g * h) f = euclideanAction g (euclideanAction h f) := by + ext x + simp only [euclideanAction_apply, mul_inv_rev, map_mul, + AffineIsometryEquiv.coe_mul, Function.comp_apply, + ContinuousLinearEquiv.apply_symm_apply] + +/-- Euclidean translations act by subtracting the displacement from the test argument. -/ +lemma euclideanAction_translation (a : TimeAndSpace d) (f : 𝓢(TimeAndSpace d, ℂ)) : + euclideanAction (EuclideanGroup.translationVector.incl (d + 1) + (Multiplicative.ofAdd (TimeAndSpace.euclideanCoordinates a))) f = + SchwartzMap.compSubConstCLM ℂ a f := by + ext x + rw [euclideanAction_apply, ← map_inv] + simp [EuclideanGroup.translationVector.incl, EuclideanGroup.toAffineIsometryHom_apply, + AffineIsometryEquiv.coe_mul, sub_eq_add_neg, add_comm] + +/-- The contragredient left Euclidean action on complex field configurations. -/ +def euclideanFieldAction (g : EuclideanGroup (d + 1)) + (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : + WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) := + ω.comp (euclideanAction g⁻¹) + +/-- The identity Euclidean transformation fixes each field configuration. -/ +@[simp] +lemma euclideanFieldAction_one (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : + euclideanFieldAction 1 ω = ω := by + apply DFunLike.ext + intro f + change ω (euclideanAction (1 : EuclideanGroup (d + 1))⁻¹ f) = ω f + simp only [inv_one, euclideanAction_one] + +/-- The inverse in duality gives a left Euclidean action on field configurations. -/ +lemma euclideanFieldAction_mul (g h : EuclideanGroup (d + 1)) + (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : + euclideanFieldAction (g * h) ω = euclideanFieldAction g (euclideanFieldAction h ω) := by + apply DFunLike.ext + intro f + change ω (euclideanAction (g * h)⁻¹ f) = + ω (euclideanAction h⁻¹ (euclideanAction g⁻¹ f)) + rw [mul_inv_rev, euclideanAction_mul] + /-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. The dimension restriction retains the source's domain of at least two total dimensions. -/ @[nolint unusedArguments] @@ -168,13 +237,37 @@ two total dimensions. -/ abbrev PositiveTimeTestFunction (d : ℕ) [Fact (1 ≤ d)] := {f : 𝓢(TimeAndSpace d, ℂ) | tsupport f ⊆ {x | 0 < x.1}} -/-- Time translation of a field by duality: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. +/-- Time translation of a complex field: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. The corresponding source convention on test functions is `T_s f(t, x) = f(t + s, x)`. The dimension restriction retains the source's domain of at least two total dimensions. -/ @[nolint unusedArguments] -def timeTranslation [Fact (1 ≤ d)] (s : ℝ) (ω : FieldConfiguration d) : - FieldConfiguration d := - ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0)) +def timeTranslation [Fact (1 ≤ d)] (s : ℝ) + (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : + WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) := + ω.comp (SchwartzMap.compSubConstCLM ℂ (⟨s⟩, 0)) + +/-- The source's time translation is the left field action by displacement `(-s, 0)`. -/ +lemma timeTranslation_eq_euclideanFieldAction [Fact (1 ≤ d)] (s : ℝ) + (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : + timeTranslation s ω = euclideanFieldAction + (EuclideanGroup.translationVector.incl (d + 1) + (Multiplicative.ofAdd (TimeAndSpace.euclideanCoordinates (-(⟨s⟩, 0))))) ω := by + apply DFunLike.ext + intro f + change ω (SchwartzMap.compSubConstCLM ℂ (⟨s⟩, 0) f) = ω (euclideanAction _ f) + simp only [map_neg, ofAdd_neg, map_inv, inv_inv, euclideanAction_translation] + +/-- Complex time translation preserves the extension of the original real field translation. -/ +lemma timeTranslation_extendRCLikeL_apply_eq_pairing [Fact (1 ≤ d)] (s : ℝ) + (ω : FieldConfiguration d) (f : 𝓢(TimeAndSpace d, ℂ)) : + timeTranslation s (WeakDual.extendRCLikeL (𝕜 := ℂ) + (ω.comp (SchwartzMap.postcompCLM Complex.reCLM))) f = + pairing (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) f := by + change WeakDual.extendRCLikeL (𝕜 := ℂ) + ((ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))).comp + (SchwartzMap.postcompCLM Complex.reCLM)) f = _ + exact extendRCLikeL_apply_eq_pairing + (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) f /-! ## C. Smeared two-point functions -/ @@ -203,19 +296,38 @@ lemma integral_bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d TimeAndSpace.euclideanCoordinates.toHomeomorph.measurableEmbedding] exact φ.integral_normed -/-- Translate a real Schwartz test by `a`, with value `f (x - a)` at `x`. -/ -def translateSchwartz (f : 𝓢(TimeAndSpace d, ℝ)) (a : TimeAndSpace d) : - 𝓢(TimeAndSpace d, ℝ) := - SchwartzMap.compSubConstCLM ℝ a f +/-- Translate a complex Schwartz test by `a`, with value `f (x - a)` at `x`. -/ +def translateSchwartz (f : 𝓢(TimeAndSpace d, ℂ)) (a : TimeAndSpace d) : + 𝓢(TimeAndSpace d, ℂ) := + SchwartzMap.compSubConstCLM ℂ a f + +/-- Translating an embedded real test and taking its real part recovers real translation. -/ +@[simp] +lemma translateSchwartz_re_ofReal (f : 𝓢(TimeAndSpace d, ℝ)) (a : TimeAndSpace d) : + SchwartzMap.postcompCLM Complex.reCLM + (translateSchwartz (SchwartzMap.postcompCLM Complex.ofRealCLM f) a) = + SchwartzMap.compSubConstCLM ℝ a f := by + ext x + rfl /-- The two-point Schwinger function smeared at `x` and zero with an arbitrary normalized bump. This follows `SmearedTwoPointFunction` in `OSforGFF`, with the bump supplied independently of the standard sequence used in the OS1 endpoint condition. -/ def SmearedTwoPointFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) (x : TimeAndSpace d) : ℝ := + let ρ := bumpToSchwartz φ + let ρℂ := SchwartzMap.postcompCLM Complex.ofRealCLM ρ SchwingerFunction₂ dμ_config - (translateSchwartz (bumpToSchwartz φ) x) - (bumpToSchwartz φ) + (SchwartzMap.postcompCLM Complex.reCLM (translateSchwartz ρℂ x)) + ρ + +/-- Complex translation of the bump preserves the original real smeared two-point function. -/ +lemma SmearedTwoPointFunction_eq_real (μ : ProbabilityMeasure (FieldConfiguration d)) + (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) (x : TimeAndSpace d) : + SmearedTwoPointFunction μ φ x = + SchwingerFunction₂ μ (SchwartzMap.compSubConstCLM ℝ x (bumpToSchwartz φ)) + (bumpToSchwartz φ) := by + simp only [SmearedTwoPointFunction, translateSchwartz_re_ofReal] /-- The standard bump sequence from `OSforGFF`, with outer radius `1 / n` for nonzero `n`. -/ def standardBumpSequence (n : ℕ) (hn : n ≠ 0) : From 6ed0998624741ac4bd2913f72ec8806f77ac043c Mon Sep 17 00:00:00 2001 From: Anna Mei Date: Mon, 16 Nov 2026 14:16:24 -0500 Subject: [PATCH 11/11] revert(QFT): restore real Glimm-Jaffe translations MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Revert 0410daca9314066eca9f4ce73e75df953d74f5ba at the user’s request, restoring the previous definitions and documentation. Co-authored-by: Codex --- Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean | 29 +--- Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean | 136 ++----------------- 2 files changed, 15 insertions(+), 150 deletions(-) diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean index 56978f1fd7..25531b3e69 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -17,8 +17,7 @@ The measure and generating-functional formulation of the Euclidean field axioms. This is a formalization of the Glimm–Jaffe variation of the Osterwalder–Schrader axioms, as presented in Glimm and Jaffe, *Quantum Physics*, Chapter 6. [ref: glimm1987quantum] -This formalism is on the generating functional, while the original OS axioms are on -the Schwinger functions. +This formalism is on the generating functional, while the original OS axioms are on the Schwinger functions. We port the predicates in `OSforGFF/OS/Axioms.lean`: analyticity (OS0), regularity (OS1), full Euclidean invariance (OS2), complex reflection positivity (OS3), and @@ -30,9 +29,6 @@ minimum of two total dimensions. OS4 uses exponentials without a factor of `i`, whereas the characteristic functional in OS0–OS3 includes that factor. -Its observables act on the complex extensions of real configurations, using Mathlib's -`WeakDual.extendRCLikeL` to apply complex time translation. The measure remains on -`FieldConfiguration d`, and this gives the same time averages as real field translation. This numbering differs from the distributional Osterwalder–Schrader axioms E0–E4. ## ii. Key results @@ -114,31 +110,12 @@ formulation, with the centering inside the time integral. -/ def OS4Ergodicity [Fact (1 ≤ d)] (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(TimeAndSpace d, ℂ)), - let A : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) → ℂ := - fun η => ∑ j, z j * Complex.exp (η (f j)) + let A : FieldConfiguration d → ℂ := fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) Tendsto (fun T : ℝ => ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, - (A (timeTranslation s (WeakDual.extendRCLikeL (𝕜 := ℂ) - (ω.comp (SchwartzMap.postcompCLM Complex.reCLM)))) - - ∫ ω', A (WeakDual.extendRCLikeL (𝕜 := ℂ) - (ω'.comp (SchwartzMap.postcompCLM Complex.reCLM))) ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) + (A (timeTranslation s ω) - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) atTop (𝓝 0) -/-- Extending real configurations before translation preserves the original real form of OS4. -/ -lemma OS4Ergodicity_iff_real [Fact (1 ≤ d)] - (μ : ProbabilityMeasure (FieldConfiguration d)) : - OS4Ergodicity μ ↔ - ∀ (n : ℕ) (z : Fin n → ℂ) (f : Fin n → 𝓢(TimeAndSpace d, ℂ)), - let A : FieldConfiguration d → ℂ := - fun ω => ∑ j, z j * Complex.exp (pairing ω (f j)) - Tendsto (fun T : ℝ => - ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, - (A (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) - - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) - atTop (𝓝 0) := by - unfold OS4Ergodicity - simp only [timeTranslation_extendRCLikeL_apply_eq_pairing, extendRCLikeL_apply_eq_pairing] - /-! ## D. Bundled axioms -/ /-- The Glimm–Jaffe axioms OS0–OS4, with ergodicity as the OS4 condition. -/ diff --git a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean index 5a07d3c006..aaf859f708 100644 --- a/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -11,7 +11,6 @@ module public import Mathlib.Analysis.Calculus.BumpFunction.InnerProduct public import Mathlib.Analysis.Calculus.BumpFunction.Normed public import Mathlib.Analysis.Normed.Lp.MeasurableSpace -public import Mathlib.Analysis.Normed.Module.WeakDual public import Mathlib.MeasureTheory.Measure.ProbabilityMeasure public import Physlib.SpaceAndTime.Space.EuclideanGroup.AffineGroup public import Physlib.SpaceAndTime.TimeAndSpace.Basic @@ -19,11 +18,11 @@ public import Physlib.SpaceAndTime.TimeAndSpace.Basic /-! # Glimm–Jaffe Euclidean fields -Test functions, field configurations and generating functionals for Euclidean fields. +Test functions, field configurations and generating functionals for a real scalar field. ## i. Overview -This is the measure-based formulation of a scalar Euclidean quantum field. +This is the measure-based formulation of a real scalar Euclidean quantum field. A field configuration is a tempered distribution `ω`, so the basic observable is its evaluation `ω f` on a real Schwartz test function `f`. A probability measure on these configurations specifies the field statistics, in a way that @@ -38,16 +37,11 @@ The parameter `d` counts spatial dimensions. Spacetime is Physlib's vector-space instances. Thus the source's total dimension is `d + 1`. Field configurations carry the weak dual topology and the cylinder sigma algebra. Their pairing with complex Schwartz functions is extended complex linearly. -The measure remains on these real configurations. Euclidean transformations and time -translation also act on complex distributions; Mathlib's `WeakDual.extendRCLikeL` -identifies the complex extension of a real configuration with its existing pairing. The full `EuclideanGroup (d + 1)` action is transported through time-first Euclidean coordinates, so it includes transformations mixing time and space. The normalized bumps are constructed in those Euclidean coordinates and pulled back to `TimeAndSpace d`, preserving the source's Euclidean mollifier sequence. -Translation acts on complex tests. Real bumps are embedded with `Complex.ofRealCLM`, -and the real part of the translated bump recovers the original real Schwartz test. The reflected conjugate combines complex conjugation with time reflection. ## ii. Key results @@ -56,7 +50,6 @@ The reflected conjugate combines complex conjugation with time reflection. * `FieldConfiguration.generatingFunctional`: the complex characteristic functional. * `FieldConfiguration.generatingFunctionalReal`: its restriction to real tests. * `reflectedConjugate`: conjugation combined with Euclidean time reflection. -* `euclideanFieldAction`: the Euclidean action on complex distributions by duality. * `SmearedTwoPointFunction`: the two-point function smeared with an arbitrary normalized bump. ## iii. Table of contents @@ -99,19 +92,6 @@ def pairing (ω : FieldConfiguration d) (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) + Complex.I * (ω (SchwartzMap.postcompCLM Complex.imCLM f) : ℂ) -/-- Mathlib's complex extension of a configuration evaluates as the field pairing. -/ -lemma extendRCLikeL_apply_eq_pairing (ω : FieldConfiguration d) - (f : 𝓢(TimeAndSpace d, ℂ)) : - WeakDual.extendRCLikeL (𝕜 := ℂ) - (ω.comp (SchwartzMap.postcompCLM Complex.reCLM)) f = pairing ω f := by - have h : SchwartzMap.postcompCLM Complex.reCLM (Complex.I • f) = - -SchwartzMap.postcompCLM Complex.imCLM f := by - ext x - simp [Complex.mul_re] - change (ω (SchwartzMap.postcompCLM Complex.reCLM f) : ℂ) - - Complex.I * (ω (SchwartzMap.postcompCLM Complex.reCLM (Complex.I • f)) : ℂ) = _ - simp [pairing, h] - /-- The characteristic functional `Z[f] = ∫ exp(i ⟨ω, f⟩) dμ` on complex tests. -/ def generatingFunctional (μ : ProbabilityMeasure (FieldConfiguration d)) (f : 𝓢(TimeAndSpace d, ℂ)) : ℂ := @@ -159,55 +139,6 @@ lemma euclideanAction_apply (g : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace ((EuclideanGroup.toAffineIsometryHom g⁻¹).map_vadd 0 (TimeAndSpace.euclideanCoordinates x)).symm -/-- The identity Euclidean transformation fixes each test function. -/ -@[simp] -lemma euclideanAction_one (f : 𝓢(TimeAndSpace d, ℂ)) : euclideanAction 1 f = f := by - ext x - simp [euclideanAction_apply] - -/-- Euclidean pullbacks give a left action on test functions. -/ -lemma euclideanAction_mul (g h : EuclideanGroup (d + 1)) (f : 𝓢(TimeAndSpace d, ℂ)) : - euclideanAction (g * h) f = euclideanAction g (euclideanAction h f) := by - ext x - simp only [euclideanAction_apply, mul_inv_rev, map_mul, - AffineIsometryEquiv.coe_mul, Function.comp_apply, - ContinuousLinearEquiv.apply_symm_apply] - -/-- Euclidean translations act by subtracting the displacement from the test argument. -/ -lemma euclideanAction_translation (a : TimeAndSpace d) (f : 𝓢(TimeAndSpace d, ℂ)) : - euclideanAction (EuclideanGroup.translationVector.incl (d + 1) - (Multiplicative.ofAdd (TimeAndSpace.euclideanCoordinates a))) f = - SchwartzMap.compSubConstCLM ℂ a f := by - ext x - rw [euclideanAction_apply, ← map_inv] - simp [EuclideanGroup.translationVector.incl, EuclideanGroup.toAffineIsometryHom_apply, - AffineIsometryEquiv.coe_mul, sub_eq_add_neg, add_comm] - -/-- The contragredient left Euclidean action on complex field configurations. -/ -def euclideanFieldAction (g : EuclideanGroup (d + 1)) - (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : - WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) := - ω.comp (euclideanAction g⁻¹) - -/-- The identity Euclidean transformation fixes each field configuration. -/ -@[simp] -lemma euclideanFieldAction_one (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : - euclideanFieldAction 1 ω = ω := by - apply DFunLike.ext - intro f - change ω (euclideanAction (1 : EuclideanGroup (d + 1))⁻¹ f) = ω f - simp only [inv_one, euclideanAction_one] - -/-- The inverse in duality gives a left Euclidean action on field configurations. -/ -lemma euclideanFieldAction_mul (g h : EuclideanGroup (d + 1)) - (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : - euclideanFieldAction (g * h) ω = euclideanFieldAction g (euclideanFieldAction h ω) := by - apply DFunLike.ext - intro f - change ω (euclideanAction (g * h)⁻¹ f) = - ω (euclideanAction h⁻¹ (euclideanAction g⁻¹ f)) - rw [mul_inv_rev, euclideanAction_mul] - /-- Complex conjugation after time reflection: `f ↦ (x ↦ conj (f (Θ x)))`. The dimension restriction retains the source's domain of at least two total dimensions. -/ @[nolint unusedArguments] @@ -237,37 +168,13 @@ two total dimensions. -/ abbrev PositiveTimeTestFunction (d : ℕ) [Fact (1 ≤ d)] := {f : 𝓢(TimeAndSpace d, ℂ) | tsupport f ⊆ {x | 0 < x.1}} -/-- Time translation of a complex field: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. +/-- Time translation of a field by duality: `(T_s ω)(f) = ω((t, x) ↦ f(t - s, x))`. The corresponding source convention on test functions is `T_s f(t, x) = f(t + s, x)`. The dimension restriction retains the source's domain of at least two total dimensions. -/ @[nolint unusedArguments] -def timeTranslation [Fact (1 ≤ d)] (s : ℝ) - (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : - WeakDual ℂ (𝓢(TimeAndSpace d, ℂ)) := - ω.comp (SchwartzMap.compSubConstCLM ℂ (⟨s⟩, 0)) - -/-- The source's time translation is the left field action by displacement `(-s, 0)`. -/ -lemma timeTranslation_eq_euclideanFieldAction [Fact (1 ≤ d)] (s : ℝ) - (ω : WeakDual ℂ (𝓢(TimeAndSpace d, ℂ))) : - timeTranslation s ω = euclideanFieldAction - (EuclideanGroup.translationVector.incl (d + 1) - (Multiplicative.ofAdd (TimeAndSpace.euclideanCoordinates (-(⟨s⟩, 0))))) ω := by - apply DFunLike.ext - intro f - change ω (SchwartzMap.compSubConstCLM ℂ (⟨s⟩, 0) f) = ω (euclideanAction _ f) - simp only [map_neg, ofAdd_neg, map_inv, inv_inv, euclideanAction_translation] - -/-- Complex time translation preserves the extension of the original real field translation. -/ -lemma timeTranslation_extendRCLikeL_apply_eq_pairing [Fact (1 ≤ d)] (s : ℝ) - (ω : FieldConfiguration d) (f : 𝓢(TimeAndSpace d, ℂ)) : - timeTranslation s (WeakDual.extendRCLikeL (𝕜 := ℂ) - (ω.comp (SchwartzMap.postcompCLM Complex.reCLM))) f = - pairing (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) f := by - change WeakDual.extendRCLikeL (𝕜 := ℂ) - ((ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))).comp - (SchwartzMap.postcompCLM Complex.reCLM)) f = _ - exact extendRCLikeL_apply_eq_pairing - (ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0))) f +def timeTranslation [Fact (1 ≤ d)] (s : ℝ) (ω : FieldConfiguration d) : + FieldConfiguration d := + ω.comp (SchwartzMap.compSubConstCLM ℝ (⟨s⟩, 0)) /-! ## C. Smeared two-point functions -/ @@ -296,38 +203,19 @@ lemma integral_bumpToSchwartz (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d TimeAndSpace.euclideanCoordinates.toHomeomorph.measurableEmbedding] exact φ.integral_normed -/-- Translate a complex Schwartz test by `a`, with value `f (x - a)` at `x`. -/ -def translateSchwartz (f : 𝓢(TimeAndSpace d, ℂ)) (a : TimeAndSpace d) : - 𝓢(TimeAndSpace d, ℂ) := - SchwartzMap.compSubConstCLM ℂ a f - -/-- Translating an embedded real test and taking its real part recovers real translation. -/ -@[simp] -lemma translateSchwartz_re_ofReal (f : 𝓢(TimeAndSpace d, ℝ)) (a : TimeAndSpace d) : - SchwartzMap.postcompCLM Complex.reCLM - (translateSchwartz (SchwartzMap.postcompCLM Complex.ofRealCLM f) a) = - SchwartzMap.compSubConstCLM ℝ a f := by - ext x - rfl +/-- Translate a real Schwartz test by `a`, with value `f (x - a)` at `x`. -/ +def translateSchwartz (f : 𝓢(TimeAndSpace d, ℝ)) (a : TimeAndSpace d) : + 𝓢(TimeAndSpace d, ℝ) := + SchwartzMap.compSubConstCLM ℝ a f /-- The two-point Schwinger function smeared at `x` and zero with an arbitrary normalized bump. This follows `SmearedTwoPointFunction` in `OSforGFF`, with the bump supplied independently of the standard sequence used in the OS1 endpoint condition. -/ def SmearedTwoPointFunction (dμ_config : ProbabilityMeasure (FieldConfiguration d)) (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) (x : TimeAndSpace d) : ℝ := - let ρ := bumpToSchwartz φ - let ρℂ := SchwartzMap.postcompCLM Complex.ofRealCLM ρ SchwingerFunction₂ dμ_config - (SchwartzMap.postcompCLM Complex.reCLM (translateSchwartz ρℂ x)) - ρ - -/-- Complex translation of the bump preserves the original real smeared two-point function. -/ -lemma SmearedTwoPointFunction_eq_real (μ : ProbabilityMeasure (FieldConfiguration d)) - (φ : ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1)))) (x : TimeAndSpace d) : - SmearedTwoPointFunction μ φ x = - SchwingerFunction₂ μ (SchwartzMap.compSubConstCLM ℝ x (bumpToSchwartz φ)) - (bumpToSchwartz φ) := by - simp only [SmearedTwoPointFunction, translateSchwartz_re_ofReal] + (translateSchwartz (bumpToSchwartz φ) x) + (bumpToSchwartz φ) /-- The standard bump sequence from `OSforGFF`, with outer radius `1 / n` for nonzero `n`. -/ def standardBumpSequence (n : ℕ) (hn : n ≠ 0) :