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..25531b3e69 --- /dev/null +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Axioms.lean @@ -0,0 +1,135 @@ +/- +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 +-/ +module + +public import Physlib.QFT.Euclidean.GlimmJaffe.Basic + +/-! +# Glimm–Jaffe axioms + +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] +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). + +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. + +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 five Glimm–Jaffe conditions OS0–OS4, with ergodicity as OS4. +* `TwoPointIntegrable`: the explicit mollifier-limit condition at the OS1 endpoint. +* `OS4Ergodicity`: convergence of centered time averages in mean square. + +## iii. Table of contents + +- A. Analyticity and regularity +- B. Euclidean invariance and reflection positivity +- C. Ergodicity +- D. Bundled axioms + +## iv. References + +* Glimm and Jaffe, *Quantum Physics*, Chapter 6. [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 + +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 → 𝓢(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 : TimeAndSpace d → ℝ, LocallyIntegrable K volume ∧ + ∀ 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`. -/ +def OS1Regularity (μ : ProbabilityMeasure (FieldConfiguration d)) : Prop := + ∃ p c : ℝ, 1 ≤ p ∧ p ≤ 2 ∧ 0 < c ∧ + (∀ f : 𝓢(TimeAndSpace 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 + 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 [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 + +/-! ## 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 +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)) + Tendsto (fun T : ℝ => + ∫ ω, ‖(1 / T : ℂ) * ∫ s in Set.Icc (0 : ℝ) T, + (A (timeTranslation s ω) - ∫ ω', A ω' ∂μ.toMeasure)‖ ^ 2 ∂μ.toMeasure) + atTop (𝓝 0) + +/-! ## D. Bundled axioms -/ + +/-- The Glimm–Jaffe axioms OS0–OS4, with ergodicity as the OS4 condition. -/ +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. -/ + regular : OS1Regularity μ + /-- OS2: full Euclidean invariance. -/ + euclideanInvariant : OS2EuclideanInvariance μ + /-- OS3: reflection positivity for complex positive-time tests and coefficients. -/ + reflectionPositive : OS3ReflectionPositivity μ + /-- 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..aaf859f708 --- /dev/null +++ b/Physlib/QFT/Euclidean/GlimmJaffe/Basic.lean @@ -0,0 +1,230 @@ +/- +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 +-/ +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.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 + +Test functions, field configurations and generating functionals for a real scalar field. + +## i. Overview + +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 +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. + +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. +* `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. + +## 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`, + `Schwinger/Defs.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 -/ + +/-- Real scalar field configurations, with the weak dual topology on tempered distributions. -/ +abbrev FieldConfiguration (d : ℕ) := WeakDual ℝ (𝓢(TimeAndSpace d, ℝ)) + +namespace FieldConfiguration + +/-- 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 : 𝓢(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 : 𝓢(TimeAndSpace d, ℂ)) : ℂ := + ∫ ω, Complex.exp (Complex.I * pairing ω f) ∂μ.toMeasure + +/-- The characteristic functional restricted to real Schwartz tests. -/ +def generatingFunctionalReal (μ : ProbabilityMeasure (FieldConfiguration d)) + (f : 𝓢(TimeAndSpace d, ℝ)) : ℂ := + ∫ ω, Complex.exp (Complex.I * (ω f : ℂ)) ∂μ.toMeasure + +end FieldConfiguration + +open FieldConfiguration + +variable {d : ℕ} + +/-! ## B. Euclidean symmetries and positive time -/ + +/-- 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 ha : (fun x => a.linearIsometryEquiv x + a 0) = a := by + funext x + 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 full Euclidean pullback expressed in time-first coordinates. -/ +@[simp] +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)))`. +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 + (SchwartzMap.compCLMOfContinuousLinearEquiv ℝ TimeAndSpace.timeReflection f) + +/-- The reflected conjugate includes both time reflection and complex conjugation. -/ +@[simp] +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 [Fact (1 ≤ d)] (f : 𝓢(TimeAndSpace d, ℂ)) : + reflectedConjugate (reflectedConjugate f) = f := by + ext x + 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` 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 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)) + +/-! ## C. Smeared two-point functions -/ + +/-- 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 → 𝓢(TimeAndSpace d, ℝ)) : ℝ := + ∫ ω, (∏ i, ω (f i)) ∂dμ_config.toMeasure + +/-- The real two-point Schwinger function evaluated on two Schwartz tests. -/ +def SchwingerFunction₂ (dμ_config : ProbabilityMeasure (FieldConfiguration d)) + (f g : 𝓢(TimeAndSpace d, ℝ)) : ℝ := + SchwingerFunction dμ_config 2 ![f, g] + +/-- Convert a smooth bump centered at zero to a real Schwartz test with integral one. -/ +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 + +/-- 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) : ℝ := + SchwingerFunction₂ dμ_config + (translateSchwartz (bumpToSchwartz φ) x) + (bumpToSchwartz φ) + +/-- The standard bump sequence from `OSforGFF`, with outer radius `1 / n` for nonzero `n`. -/ +def standardBumpSequence (n : ℕ) (hn : n ≠ 0) : + ContDiffBump (0 : EuclideanSpace ℝ (Fin (d + 1))) 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 diff --git a/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean b/Physlib/SpaceAndTime/TimeAndSpace/Basic.lean index 6f855507f5..0a7bcb90d2 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,55 @@ 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. -/ +lemma timeReflection_involutive (tx : TimeAndSpace d) : + timeReflection (timeReflection tx) = tx := by + simp only [timeReflection_apply, neg_neg] + end TimeAndSpace namespace Space 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..1ccc17716b 100644 --- a/scripts/lint/exemptions/spellingWords.txt +++ b/scripts/lint/exemptions/spellingWords.txt @@ -1,4 +1,18 @@ boundedness +analyticity +Cherkis +cylinder +ergodicity +functionals +Glimm +mollified +mollifier +osforgff +pairing +pullback +reconstruction +reflection +reflections coefficient comp complexification