diff --git a/Outline.md b/Outline.md new file mode 100644 index 000000000..4847e9e61 --- /dev/null +++ b/Outline.md @@ -0,0 +1,566 @@ +# Outline of the full derivation + +Basic rules of this outline: +- Everything should be bullet points. +- Each bullet point contain a single logical concept. +- The distance between two bullet points in locical jumps should be small. + +## Goal + +- The goal of this project is to formalize the form of the + Standard Model Lagrangian at an implicit point `x₀`. +- The lagrangian depends only on the fields and their derivatives at `x₀`. +- In reality, the EFT lagrangian is a formal infinite sum of terms of all + mass dimensions. +- However, the questions physicists ask are about truncations of this sum, + for example: "what is the form of the SM lagrangian up to mass dimension `n`?". +- Such truncations are always finite polynomials in the fields and their + derivatives, because at each mass dimension there are only finitely many + independent terms. +- It therefore suffices to work with finite polynomials: classifying the + invariant terms at each mass dimension answers every truncated question. +- If ever needed, the full infinite sum can be recovered as a formal series + over mass dimensions (the graded completion), without changing the + underlying algebra of finite polynomials. + +- To make our API widly useable we however, generalize a lot of the arguments here. + +- The broad symmetry argument falls into three categories: + - The covariant reduction + - The Lorentz invariance + - The global gauge group invariance. + +## Jet ring + +- Fix a spacetime point `x₀`, called the base point, at which all field values and + derivatives appearing below are evaluated. +- A local lagrangian evaluated at `x₀` depends on a field only through the values of + its derivatives at `x₀`. +- For a smooth complex-valued field `φ`, its infinite formal jet at `x₀` is the + collection of all these derivative values. +- The type `Fin 1 ⊕ Fin 3` indexes the four spacetime directions: one temporal + direction and three spatial directions. +- A multi-index records how many derivatives are taken in each spacetime direction. +- We represent such a multi-index by `s : Multiset (Fin 1 ⊕ Fin 3)`. +- A multiset is an unordered collection with repetitions, where the multiplicity of + a direction records how many derivatives are taken in that direction. +- For example, the multiset containing `μ` twice and `ν` once represents the + derivative `∂_μ ∂_μ ∂_ν`. +- A multiset is sufficient because ordinary partial derivatives commute, so only + the multiplicity of each direction matters, not their order. +- We model this derivative data by a formal power series in four spacetime variables. +- We define `JetRing := MvPowerSeries (Fin 1 ⊕ Fin 3) ℂ`. +- The word "formal" means that the spacetime variables are indeterminates: they + record spacetime directions and derivative orders but are not assigned numerical + coordinate values. +- A formal power series is therefore treated as an arbitrary family of coefficients + equipped with algebraic operations, rather than as an infinite sum that must be + evaluated. +- Thus an element of `JetRing` records local Taylor data rather than a function + defined on all of spacetime. +- Here "jet" means a formal Taylor jet at a point and is unrelated to the particle + jets of collider physics. +- The constant coefficient of `φ : JetRing` represents the value `φ(x₀)`. +- The coefficient at a multi-index `s` records the corresponding Taylor-series + coefficient. +- For `s : Multiset (Fin 1 ⊕ Fin 3)`, let `∂_s| φ` denote the base-point value of + the iterated formal derivative in the directions recorded by `s`. +- The value `∂_s| φ` is the coefficient at `s` multiplied by the corresponding + product of factorials. +- Formal partial differentiation advances the derivative tower by one spacetime + direction. +- More precisely, differentiating in direction `μ` sends the derivative value + indexed by `s` to the value indexed by `s + {μ}`. +- The formal partial derivatives on `JetRing` commute, matching the multiset + representation of ordinary derivatives introduced above. +- Every smooth complex-valued field `f` determines an element of `JetRing` by taking + its formal Taylor series at `x₀`. +- Borel's theorem states that every element of `JetRing` is the formal Taylor series + at `x₀` of at least one smooth complex-valued field. +- In the notation above, Borel's theorem states: + + `∀ Φ : JetRing, ∃ f ∈ C∞(ℝ⁴, ℂ), ∀ s : Multiset (Fin 1 ⊕ Fin 3), ∂_s f(x₀) = ∂_s| Φ`. + +- No convergence condition is required, so this includes formal Taylor series with + radius of convergence zero. +- Therefore, `JetRing` contains all possible derivative towers of smooth + complex-valued fields at the base point. +- Two fields with the same jet at `x₀` are indistinguishable to a local Lagrangian + evaluated at `x₀`. +- Addition in `JetRing` records addition of local Taylor data. +- Multiplication in `JetRing` models multiplication of local functions at the level + of their Taylor data. +- When a derivative indexed by `s` is applied to a product, the derivatives recorded + by `s` are distributed between the two factors. +- We write `p + q = s` when `p` records the derivatives assigned to the first factor + and `q` records those assigned to the second. +- Here addition means combining the two multisets of derivative directions, + including their repetitions. +- For each decomposition `p + q = s`, the coefficient of the first factor at `p` is + multiplied by the coefficient of the second factor at `q`. +- Summing these products over all decompositions `p + q = s` defines the standard + convolution product of formal power series. +- When expressed in terms of the base-point derivative values `∂_s|`, each + decomposition is weighted by the corresponding multinomial coefficient `C(s, p)`. +- Thus multiplication in `JetRing` reproduces the usual higher-order Leibniz rule. +- Complex conjugation acts coefficientwise on `JetRing`. +- The formal spacetime variables are fixed by complex conjugation. +- For `n : ℕ`, truncation at order `n` discards all coefficients of total derivative + order greater than `n`. +- Truncation is not a ring homomorphism into `JetRing`, because multiplying truncated + series can produce terms above order `n`. +- Nevertheless, a product through order `n` depends only on its factors through + order `n`. +- The infinite ring lets one define a single symmetry action for every derivative + order. +- Any individual finite polynomial lagrangian uses only finitely many components of + this infinite derivative tower. +- Vector-valued field jets and matrix-valued gauge-transformation jets are + constructed from this scalar coefficient ring. + +## Jet component spaces + +- For a vector space `V`, the space `JetRing ⊗[ℂ] V` describes the jets of all functions `f : SpaceTime → V`. + +- As an example, consider a theory for a field valued in `V`. +- A physicist writes the lagrangian as a polynomial in symbols such as + `ψ_α`, `d_μ ψ_α`, `d_μ d_ν ψ_α`. +- To formalize the lagrangian, we must first say what kind of object a + symbol `d_s ψ_α` is. +- The symbol `d_s ψ_α` is a machine which takes a field and returns a + number: the `s`-th derivative of its `α`-th component at `x₀`. +- A field enters only through its jet, so `d_s ψ_α` is a linear functional + on `JetRing ⊗[ℂ] V`: it sends the jet `f` to its Taylor coefficient + `∂_s| f_α`. +- In other words, the symbols are the coordinate functions on the space of + jets. +- When `V` is a complex vector space, the physicist also writes conjugate + symbols `d_s ψ̄_α`, e.g. in the mass term `ψ̄ ψ`. +- These are genuinely new: a polynomial in the `d_s ψ_α` alone depends + holomorphically on the field, and real terms like `ψ̄ ψ` are not + holomorphic. +- The symbol `d_s ψ̄_α` sends the jet `f` to the complex conjugate of + `∂_s| f_α`; it is conjugate-linear in `f`, i.e. a linear functional on + the conjugate space of `JetRing ⊗[ℂ] V`. +- The physicists' practice of treating `ψ` and `ψ̄` as independent + variables is exactly this: conjugation is not complex-linear, so the + conjugate symbols cannot be built from the `d_s ψ_α` and enter as + independent coordinate functions. +- We define the jet component space `JetComponentSpace` to be the span of + the symbols `d_s ψ_α` and `d_s ψ̄_α` together; they form a basis, indexed + by the pairs `(s, α)` with a bar/no-bar tag. +- This span is smaller than the full dual of `JetRing ⊗[ℂ] V`, which also + contains non-local functionals — e.g. evaluation of the field at a point + other than `x₀` — depending on infinitely many derivatives at once; + locality is precisely the restriction to the span of the symbols. +- Formally, `JetComponentSpace = (DerivAlgebra ⊗[ℂ] Module.Dual ℂ V) × + (DerivAlgebra ⊗[ℂ] Module.Dual ℂ (ConjModule V))`, where `DerivAlgebra` + is the span of the functionals `∂_s|` on `JetRing`, and the second factor + is dropped when `V` is real (its conjugate is then not independent). +- The lagrangian — a polynomial in the symbols — is then an element of the + symmetric (for bosons) or exterior (for fermions) algebra over + `JetComponentSpace`. + +### The group action on the symbols + +- Let a group act on fields by `f ↦ ρ(U) f`. +- Because the symbols are functions of the field, their transformation is + not extra data — it is inherited: the transformed symbol is the symbol + evaluated on the transformed field. +- Evaluating on the transformed field gives + `ψ_α(ρ(U) f) = ∑_β ρ(U)_{α β} ψ_β(f)` — exactly the physicists' + substitution rule, now derived rather than postulated. +- As an operation on symbols this is precomposition, `φ ↦ φ ∘ ρ(U)`, which + composes in reverse order: acting with `U` then `V` yields `ρ(U V)`, not + `ρ(V U)` — a right action. +- A `Representation` is a left action, so one inverse must be inserted: + `U · φ := φ ∘ ρ(U)⁻¹`. +- This inverse is the familiar one in `φ'(x) = φ(Λ⁻¹ x)` for a scalar + field: a function transforms with the inverse of the transformation of + its argument. +- The symbols therefore transform in the dual (contragredient) + representation, opposite to the field itself. +- The conjugate symbols inherit their transformation the same way: + `ψ̄_α(ρ(U) f) = ∑_β conj(ρ(U)_{α β}) ψ̄_β(f)` — the physicists' rule + `ψ̄ ↦ ψ̄ U†` for a unitary representation. +- Invariance is unaffected: a lagrangian is invariant under all `U` if and + only if it is invariant under all `U⁻¹`, so both conventions single out + exactly the same invariant lagrangians. + +## Jet gauge group + +- Let`JetGaugeGroup` be a (matrix) jet gauge group + +### The jet Lie algebra + +- Let `JetLieAlgebra` be the Lie algebra of `JetGaugeGroup`. +- Let `κ : Type` be the indexing set of a basis `T_a` of `JetLieAlgebra`. +- We let `f : κ → κ → κ → ℂ` be the structure constants of the Lie algebra + with respect to the basis `T_a`, so that: + `[T_a, T_b] = i ∑_c f^c_{a b} · T_c` +- An element `X : JetLieAlgebra` has components `X^a : JetRing` with respect to the + basis `T_a`. +- There is a derivative `∂ : Fin 1 ⊕ Fin 3 → JetLieAlgebra → JetLieAlgebra`, acting + componentwise: `(∂_μ X)^a = ∂_μ (X^a)`. +- Each `∂_μ` is a derivation of the bracket: `∂_μ [X, Y] = [∂_μ X, Y] + [X, ∂_μ Y]`. +- Taylor coefficients act componentwise too: `∂_s| X` is the constant Lie algebra + element with components `∂_s|(X^a) : ℂ`. + +### Maurer-Cartan form + +- There is a map `ω : JetGaugeGroup → (Fin 1 ⊕ Fin 3) → JetLieAlgebra` + defined by `ω_μ(U) := i (∂_μ U) U†`. This mp is called the Maurer-Cartan form. +- We let `ω^a_μ(U)` for `a : κ` denote the component of `ω` with respect to the `a`th + basis element. +- The adjoint action is the action of`JetGaugeGroup` on `JetLieAlgebra` by conjugation. +- We denote the components of this action as `Ad(U)^a_b` for `U : JetGaugeGroup`. +- The Maurer–Cartan form is a twisted cocycle: for `U V : JetGaugeGroup`, + + `ω_μ(U * V) = ω_μ(U) + U ω_μ(V) U†`. +- In components this reads as: + `ω^a_μ(U * V) = ω^a_μ(U) + ∑_b Ad(U)^a_b ω^b_μ(V)`. +- Two consequences: `ω_μ(1) = 0`, and `ω_μ(U⁻¹) = − Ad(U⁻¹) ω_μ(U)`. +- The Maurer–Cartan form satisfies the structure equation: for any `U`, + + `∂_μ ω^a_ν(U) − ∂_ν ω^a_μ(U) = ∑_{b c} f^a_{b c} · ω^b_μ(U) · ω^c_ν(U)` + +- Define `sym(∂_s| ω^a_μ(U)) := (1/(|s|+1)) ∑_{ν ∈ s+μ} ∂_{(s+μ)−ν}| ω^a_ν(U)`. +- We have that: + `∂_s| ω^a_μ − sym(∂_s| ω^a_μ) ∈ ℂ-span{ ∂_{s'}|(∂_ν ω^a_λ − ∂_λ ω^a_ν) : s' + ν + λ = s + μ }`. + +### Pure jet subgroup + +- For `U : JetGaugeGroup` we write `U₀` for its base-point value, viewed as a + constant jet. +- Let `PureJetGaugeGroup ⊆ JetGaugeGroup` be the subgroup of `U` with `U₀ = 1`. +- Every `U` factors uniquely as `U = (U U₀⁻¹) · U₀` with `U U₀⁻¹ : PureJetGaugeGroup`. +- Hence `JetGaugeGroup = PureJetGaugeGroup ⋊ G`, with `G` the subgroup of constant + jets. + +- By the structure equation and the multiplication rule, each spanning element equals + `∑_{b c} f^a_{b c} ∑_{p + q = s'} C(s', p) · ∂_p| ω^b_ν · ∂_q| ω^c_λ`, + in which every factor has order `≤ |s'| = |s| − 1`. +- Hence, by induction on order: for each `(s, μ, a)` there is a polynomial `P^a_{s μ}` + over `ℂ`, in commuting variables `X^b_{r ν}` indexed by multisets `r` with `|r| ≤ |s|`, + such that for every pure jet `U`: + + `∂_s| ω^a_μ(U) = P^a_{s μ}[ X^b_{r ν} := sym(∂_r| ω^b_ν(U)) ]` + +- The point is that `P^a_{s μ}` does not depend on `U`: the same polynomial works for + every pure jet. +- The recursion defining `P^a_{s μ}`: start from `X^a_{s μ}`, add the span-decomposition + correction with each antisymmetrized pair replaced via the structure equation, and + substitute lower-order `P`'s for the `∂_p| ω` factors that appear. +- A pure jet is recovered from its Maurer–Cartan form by the coefficient recursion + `∂_{s+μ}| U = −i ∑_{p + q = s} C(s, p) ∂_p| ω_μ(U) · ∂_q| U`, with `∂_0| U = 1`. +- Injectivity: two pure jets with the same symmetric parts have the same `ω` (previous + induction), hence the same recursion, hence are equal. +- Surjectivity: given a symmetric family, define the coefficients of `ω` order by + order — symmetric parts as prescribed, the complement by the structure equation — + and then define `U` by the recursion; the structure equation is exactly the + consistency condition making both recursions well-defined. +- Note `sym(∂_s| ω^a_μ(U))` depends only on the combined multiset `r := s + μ`, + so the symmetric data of `U` is a function of `(a, r)` with `r` nonempty. +- Define + + `symmetrizedMaurerCartanCoeff : PureJetGaugeGroup → κ → { r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0 } → ℂ` + + `symmetrizedMaurerCartanCoeff U a r := (1/|r|) ∑_{ν ∈ r} ∂_{r − ν}| ω^a_ν(U)` + +- Total symmetry is automatic: the codomain is indexed by the multiset `r`, so there + is no symmetry side-condition to impose. +- Lemma (freeness): `Function.Bijective symmetrizedMaurerCartanCoeff`. +- Remark: this is the `sym(d_s A)` argument with the roles reversed — for `ω` the + "field strength" vanishes identically (the structure equation), so nothing survives + except the symmetric parts. + +### Jet representations + +- We define a representation of `JetGaugeGroup` as the following data: + - a homomorphism `jρ : JetGaugeGroup → Matrix ι ι JetRing` + - an `ℝ`-linear map `dρ : GaugeAlgebra →ₗ[ℝ] Matrix ι ι ℂ` such that: + - Bracket: `dρ ⁅X, Y⁆ = i (dρ X · dρ Y − dρ Y · dρ X)`. + Equivalently, `X ↦ i • dρ X` is a morphism of real Lie algebras into + `Matrix ι ι ℂ` with the commutator bracket. + - Equivariance: `ρ₀(U) · dρ X · ρ₀(U)⁻¹ = dρ (Ad(U₀) X)` + such that + - Compatibility: `∂_μ jρ(U) = -i · dρ̂(ω_μ(U)) · jρ(U)` +- Here `dρ̂ : JetGaugeAlgebra → Matrix ι ι JetRing` is the coefficientwise + (`JetRing`-linear) extension of `dρ`, characterized by + `∂_r|(dρ̂ Z) = dρ (∂_r| Z)` for every multiset `r`. In the basis `T_a` it is + `dρ̂ Z = ∑_a Z^a • dρ_a` with `dρ_a := dρ T_a`, and the conditions above + recover the component form: `[dρ_a, dρ_b] = i ∑_c f^c_{a b} · dρ_c`. +- We will denote a Jet representation as `jρ`, dropping the `dρ` data for notational + ease. +- The general derivatives of `jρ(U)` are then given by: + `∂_{s + μ}|(jρ(U)) = -i ∑_{p + q = s} C(s, p) ∑_a ∂_p|(ω^a_μ(U)) · dρ_a · ∂_q|(jρ(U))` +- We let `ρ₀(U) := ∂_0|(jρ(U))`; note `ρ₀(U)` depends only on the base value `U₀`. + +#### `dρ` is determined by `jρ` + +- For `X : GaugeAlgebra` and a coordinate `μ`, let `U_X := exp(-i x^μ • X)` be the + corresponding linear pure jet (a formal power-series exponential; it is a unitary + jet since `X` is hermitian, has base value `1`, and `∂_0| ω_ν(U_X) = δ_{ν μ} X`). +- Evaluating compatibility at the base point gives `∂_μ|(jρ(U_X)) = -i · dρ X`, so + + `dρ X = i ∂_μ|(jρ(U_X))`. + +- Hence `dρ` is uniquely determined by `jρ`: two jet representations with the same + `jρ` are equal. We nevertheless carry `dρ` as data — an abstract homomorphism + cannot be differentiated, so a `jρ`-only definition would have to existentially + quantify over `dρ`; carrying the field with this uniqueness lemma is more + convenient. +- The bracket and equivariance conditions are then derivable from the homomorphism + property together with compatibility (so they may be demoted to lemmas when + constructing instances): + - equivariance by applying compatibility to `U₀ V U₀⁻¹`, using the cocycle + identity `ω_μ(U₀ V U₀⁻¹) = Ad(U₀) ω_μ(V)` for constant `U₀`; + - the bracket from the symmetry of `∂_μ ∂_ν` together with the structure + equation, tested on the linear jets `U_X`. +## The algebra + +- Let `B` be an algebra over `ℂ`. +- Let `JetGaugeGroup` act on `B` via algebra homomorphisms +- We write `U · x` for the action of `U : JetGaugeGroup` and `x : B`. + +## Gauge bosons + +- We say collection `A : Fin 1 ⊕ Fin 3 → κ → B` is a collection of gauge bosons + if they transform as: + - `U · (d_s A^a_μ) = ∑_{p + q = s} C(s, p) ∑_b ∂_p|(Ad(U)_{a b}) · d_q A^b_μ + ∂_s(ω^a_μ(U)) · 1` + +## Transforms under a rep + +- We say a collection `ψ : ι → B` transforms under `jρ` if + `U · (d_s ψ_i) = ∑_{p + q = s} C(s, p) ∑_j ∂_p|(jρ(U)_{i j}) · d_q ψ_j` + which can be seen as the expansion of `d_s (∑_j jρ(U)_{i j} · ψ_j)`. +- In terms of `dρ` this is equivalent to: the base case + + `U · ψ_i = ∑_j ρ₀(U)_{i j} · ψ_j` + + together with the recursion + + `U · (d_{s + μ} ψ_i) = d_μ (U · (d_s ψ_i)) − i ∑_{p + q = s} C(s, p) ∑_a ∂_p|(ω^a_μ(U)) ∑_j (dρ_a)_{i j} · (U · (d_q ψ_j))` + + which determines the transformation of each derivative from those of lower order, + with the admixture governed only by the Maurer–Cartan jets and `dρ`. +- At `s = 0` the recursion reads + + `U · (d_μ ψ_i) = d_μ (U · ψ_i) − i ∑_a ∂_0|(ω^a_μ(U)) ∑_j (dρ_a)_{i j} · (U · ψ_j)` + + i.e. the action fails to commute with `d_μ` exactly by the `dρ`-admixture at the + base-point Maurer–Cartan coefficient. + +# B. The covariance reduction + +- In practice we never want to use the full gauge group, instead just the global gauge + group. +- To do this we do what we call the `covariance reduction`. This corresponds + to replacing gauge bosons with field strengths and derivatives with + covariant derivatives. +- This covariant reduction turns into three disinct theorems: + 1. `Span(d_s ψ_i, d_s A^μ) = Span(∇_l ψ_i, d_s A^μ )` + This replaces derivatives of fermions or complex scalars with covariant + derivatives. + 2. `Adjoin(d_s A^μ) = Adjoin(symm_s A, ∇_l F^μν)` + This replaces derivatives of gauge bosons with field strengths, their + covariant derivatives and symmetrized derivatives of gauge bosons. + 3. `Invariants(Adjoin(d_s A^μ, S)) = Invariants(Adjoin(∇_l F^μν, S))` + if `S` only transform through the base value of the gauge group. + + +## B.1. The covariant derivative + +- For a representation `jρ` based on the indexing set `ι` we define the covariant + derivative as a map `𝒟 : Fin 1 ⊕ Fin 3 → (ι → B) → (ι → B)` such that + `(𝒟_μ ψ)_i = d_μ ψ_i + i ∑_a ∑_j (dρ_a)_{i j} · A^a_μ · ψ_j`. +- We and iterate `𝒟` to define the covariant tower + `𝒟_l ψ` for lists `l`. + +### B.1.2 The transformation of covariant dervatives + +- Theorem: if `ψ` transforms under `jρ` then `𝒟_μ ψ` transforms under `jρ`. + +### B.1.3 The unitriangularity of covariant derivatives + +- Write `⟨A⟩ := adjoin({ d_p A^a_μ })` for the subalgebra of `B` generated by the + gauge bosons and their derivatives. +- For `S ⊆ B`, the `⟨A⟩`-span of `S` is the left `⟨A⟩`-submodule + `{ ∑_k P_k · x_k : P_k ∈ ⟨A⟩, x_k ∈ S }`. +- Lemma (unitriangularity): for every list `l`, + + `𝒟_s ψ_i − d_l ψ_i ∈ ⟨A⟩-span of { d_q ψ_j : |q| < |l|, j : ι }` + + i.e. the covariant derivative equals the ordinary one plus `⟨A⟩`-combinations of + strictly lower-order derivatives. +- This is the whole content; the useful consequences follow by induction on order: + - For every `n`, the families `{ d_q ψ_j : |q| ≤ n }` and `{ 𝒟_q ψ_j : |q| ≤ n }` + span the same left `⟨A⟩`-module — the change of generators is invertible and + triangular. + - Hence for every `n`: + + `adjoin( ⟨A⟩ ∪ { d_q ψ_j : |q| ≤ n } ) = adjoin( ⟨A⟩ ∪ { 𝒟_q ψ_j : |q| ≤ n } )` + + and taking the union over all `n`, the two towers generate the same subalgebra of + `B` relative to the connection. + +## B.2 Field strengths + +- We define the field strengths `F : κ → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → B` as follows: + `F^a_{μν} = d_μ A^a_ν − d_ν A^a_μ − ∑_{b c} f^a_{b c} · A^b_μ · A^c_ν` +- They transform with under to the (jet version) of the adjoint-representation. +- We thus have the covariant tower `𝒟_q F^a_{μν}`. + +## B.3 Symmetrized indices of adjoints + +- Define the symmetrized index + `sym(d_s A^a_μ) := (1/(|s|+1)) ∑_{ν ∈ s+μ} d_{(s+μ)−ν} A^a_ν` +- Note that `d_s A^a_μ − sym(d_s A^a_μ) = (1/(|s|+1)) ∑_{ν ∈ s+μ} (d_s A^a_μ − d_{(s+μ)−ν} A^a_ν)`, + and each summand is a pair of terms differing only in which index carries the `A`: + moving the `A`-index from `ν` to `μ` gives `d_{s'}(d_ν A^a_μ − d_μ A^a_ν)` with + `s' = (s + μ) − ν − μ`. +- Then + `d_s A^a_μ − sym(d_s A^a_μ) ∈ ℂ-span{ d_{s'}(d_ν A^a_λ − d_λ A^a_ν) : s' + ν + λ = s + μ }` +- But we have: + `d_{s'}(d_ν A^a_λ − d_λ A^a_ν) = d_{s'} F^a_{νλ} + ∑_{b c} f^a_{b c} · d_{s'}(A^b_ν · A^c_λ)` +- By the multiplication rule the last term expands as + `d_{s'}(A^b_ν · A^c_λ) = ∑_{p + q = s'} C(s', p) · d_p A^b_ν · d_q A^c_λ` + in which every factor has order `≤ |s'| = |s| − 1`. +- So: + `d_{s'}(d_ν A^a_λ − d_λ A^a_ν) − d_{s'} F^a_{νλ} ∈ adjoin({ d_p A^b_ν : |p| < |s| })`. +- Since `F` transforms in the adjoint, the unitriangularity lemma applies to it: + `d_{s'} F^a_{νλ} − 𝒟_{s'} F^a_{νλ} ∈ ⟨A⟩-span{ d_q F^a_{νλ} : |q| < |s'| }` + and (inspecting the coefficients produced by iterating `𝒟`) everything on the + right lies in `adjoin({ d_p A : |p| < |s| })`. +- Chaining the three memberships: + `d_s A^a_μ ∈ ℂ-span{ sym(d_s A^a_μ) } + ℂ-span{ 𝒟_{s'} F^a_{νλ} : |s'| = |s| − 1 } + adjoin({ d_p A : |p| < |s| })`. +- By induction on order (base case: `A^a_μ = sym(A^a_μ)`): + `adjoin({ d_p A : |p| ≤ n }) = adjoin({ sym(d_p A) : |p| ≤ n } ∪ { 𝒟_q F : |q| < n })`. + +## B.4 Pure jets and the free action + +- Let `N ⊆ JetGaugeGroup` be the subgroup of pure jets: those `U` with `U₀ = 1`. +- Every `U` factors as `U = (U U₀⁻¹) · U₀` with `U U₀⁻¹ ∈ N`, so + `JetGaugeGroup = N ⋊ G` with `G` the constant jets. +- If an element of `B` transforms only through `U₀` — e.g. the covariant towers + `𝒟_q ψ` and `𝒟_q F` — then `N` acts trivially on it. +- On a symmetric part, `U ∈ N` acts through the gauge boson law (applied to the + ℂ-linear combination defining `sym`): + + `U · sym(d_s A^a_μ) = sym(d_s A^a_μ) + sym(∂_s| ω^a_μ(U)) + (terms in { d_p A^b_ν : |p| < |s| })` + + i.e. a shift by the symmetrized Maurer–Cartan jet, up to lower order (the + lower-order terms carry `∂_p|(Ad(U))` coefficients with `p ≠ 0`). +- Lemma (freeness): the map + + `N → { totally symmetric families c^a_{s+μ} } : U ↦ ( sym(∂_s| ω^a_μ(U)) )_{s, μ, a}` + + is a bijection — the symmetrized Maurer–Cartan jets of a pure jet can be + prescribed freely and independently, order by order. + +## B.5 Invariants factor through the field strength + +- Let `S ⊆ B` be a set of elements each transforming only through `U₀` — e.g. the + covariant tower `{ 𝒟_q ψ_j }`. +- Theorem: + + `invariants of adjoin({ d_p A^a_μ } ∪ S) under JetGaugeGroup = invariants of adjoin({ 𝒟_q F^a_{μν} } ∪ S) under G` + +- Easy direction (⊇): `𝒟_q F` lies in `adjoin({ d_p A } ∪ S)` by construction and + transforms through `U₀` alone, so a `G`-invariant built from `{ 𝒟_q F } ∪ S` is + `JetGaugeGroup`-invariant. +- Hard direction (⊆): let `x ∈ adjoin({ d_p A } ∪ S)` be `JetGaugeGroup`-invariant. +- By the change of generators, write `x` as a polynomial in the symmetric parts + `sym(d_p A)` with coefficients in `adjoin({ 𝒟_q F } ∪ S)`. +- Act with `U ∈ N`: the coefficients are fixed, and each symmetric part is shifted + by the free constant `sym(∂_p| ω(U))` of the lemma, up to lower-order symmetric + parts — so work by downward induction on the top order appearing in `x`. +- Invariance under all of `N`, with the shifts freely prescribable, forces `x` to be + constant in every symmetric variable: substitute the shift and compare + coefficients — equivalently, evaluate on the "slice" where all symmetric parts are + set to zero. +- Hence `x ∈ adjoin({ 𝒟_q F } ∪ S)`. +- Finally, by `JetGaugeGroup = N ⋊ G`, the remaining invariance is under the + constant jets, which act through `U₀` — i.e. `x` is a `G`-invariant of + `adjoin({ 𝒟_q F } ∪ S)`, completing the equality. + + +## C. Lorentz Invariance + +- Within the Standard model, after the covarance-reduction + there are on three types of particles, field-strengths, + LH weyl fermions and RH weyl fermions. +- We want to define collections of these objects in + arbitary groups. + +## C.1. Boost weights + +## C.2 IsLorentzFieldStrength + +## C.3 IsLorentzLeftFermion + +## D. The Standard Model +Once covariance has been taken care of, the algebra +generated by the following: +- Fermions: `u`, `d`, `L`, `Q`, `e`, their conjugates and their covariant deriatives +- Bosons: `H` (the higgs), its conjugate, and its covariant derivatives +- Gauge bosons: the field strenghts of `G`, `B` and `W`, and their covariant derivatives. + +Every term with half-integer mass-dimension is zero. + +Up to dimension 4, and taking no symmetry into consideration we have the following +collection of terms: + +- Mass dimensions of the letters: `[H] = 1`, `[ψ] = 3/2` (for `ψ ∈ {u, d, L, Q, e}` + or a conjugate), `[F] = 2` (for `F ∈ {G, B, W}`), and each `d_μ` adds `1`. +- A "term" is a multiset of letters `d_s H`, `d_s ψ`, `d_s F` (any `s`) whose + dimensions sum to at most `4`; enumerating by letter-count gives a finite list. + +### One `H` + +- `H`, `d_μ H`, `d_{μν} H`, `d_{μνλ} H` — dimensions `1, 2, 3, 4`. + +### Two `H`'s + +- `H H` — dimension `2`. +- `H (d_μ H)` — dimension `3`. +- `(d_μ H)(d_ν H)` and `H (d_{μν} H)` — dimension `4`. + +### Three `H`'s + +- `H H H` — dimension `3`. +- `H H (d_μ H)` — dimension `4`. + +### Four `H`'s + +- `H H H H` — dimension `4`. + +### One `F` + +- `F_{μν}`, `d_λ F_{μν}`, `d_{λρ} F_{μν}` — dimensions `2, 3, 4`. + +### `H` together with `F` + +- `H F_{μν}` — dimension `3`. +- `(d_μ H) F_{νλ}` and `H (d_λ F_{μν})` — dimension `4`. +- `H H F_{μν}` — dimension `4`. + +### Two `F`'s + +- `F_{μν} F_{λρ}` — dimension `4`. + +### Two `ψ`'s + +- `ψ_i ψ̄_j` — dimension `3`. +- `(d_μ ψ_i) ψ̄_j` — dimension `4`. + +### `H` together with two `ψ`'s + +- `H ψ_i ψ̄_j` — dimension `4`. + +- No term with four or more `ψ`'s, or with a `ψ` together with an `F`, fits within + dimension `4` (`4 · 3/2 = 6 > 4`, and `3/2 + 2 = 7/2` is already odd-dimensional + and cannot appear alone). +- This list is purely a dimension count: it does not yet select which index + contractions are Lorentz scalars or gauge singlets — that reduction is the work + of sections B and C. diff --git a/Physlib.lean b/Physlib.lean index 7d0fe574a..6d3e35575 100644 --- a/Physlib.lean +++ b/Physlib.lean @@ -121,13 +121,17 @@ public import Physlib.Mathematics.LinearPMap public import Physlib.Mathematics.List public import Physlib.Mathematics.List.InsertIdx public import Physlib.Mathematics.List.InsertionSort +public import Physlib.Mathematics.MvPolynomialTranslation +public import Physlib.Mathematics.MvPowerSeriesDerivative public import Physlib.Mathematics.OrthogonalMatrix public import Physlib.Mathematics.PiTensorProduct +public import Physlib.Mathematics.PolynomialEval public import Physlib.Mathematics.RatComplexNum public import Physlib.Mathematics.Resolvent public import Physlib.Mathematics.SO3.Basic public import Physlib.Mathematics.SchurTriangulation public import Physlib.Mathematics.SpecialFunctions.PhysHermite +public import Physlib.Mathematics.SymmetricAlgebra public import Physlib.Mathematics.Trigonometry.Tanh public import Physlib.Mathematics.VariationalCalculus.Basic public import Physlib.Mathematics.VariationalCalculus.HasVarAdjDeriv @@ -182,6 +186,18 @@ public import Physlib.Particles.FlavorPhysics.CKMMatrix.Rows public import Physlib.Particles.FlavorPhysics.CKMMatrix.StandardParameterization.Basic public import Physlib.Particles.FlavorPhysics.CKMMatrix.StandardParameterization.StandardParameters public import Physlib.Particles.NeutrinoPhysics.Basic +public import Physlib.Particles.QED.Basic +public import Physlib.Particles.QED.CurrentCoupling +public import Physlib.Particles.QED.Evaluation +public import Physlib.Particles.QED.FermionStatistics +public import Physlib.Particles.QED.FieldStrength +public import Physlib.Particles.QED.Fields +public import Physlib.Particles.QED.GammaMatrices +public import Physlib.Particles.QED.GaugeInvariance +public import Physlib.Particles.QED.JetCompleteness +public import Physlib.Particles.QED.Lagrangian +public import Physlib.Particles.QED.LorentzInvariance +public import Physlib.Particles.QED.MassDimension public import Physlib.Particles.StandardModel.AnomalyCancellation.Basic public import Physlib.Particles.StandardModel.AnomalyCancellation.FamilyMaps public import Physlib.Particles.StandardModel.AnomalyCancellation.NoGrav.Basic @@ -190,13 +206,59 @@ public import Physlib.Particles.StandardModel.AnomalyCancellation.NoGrav.One.Lin public import Physlib.Particles.StandardModel.AnomalyCancellation.Permutations public import Physlib.Particles.StandardModel.Basic public import Physlib.Particles.StandardModel.Fermions.DownSinglet +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Basic public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet -public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.MassDim +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetComponentSpace public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet public import Physlib.Particles.StandardModel.Fermions.UpSinglet +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Invariants +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.MassDim +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition public import Physlib.Particles.StandardModel.HiggsBoson.Basic public import Physlib.Particles.StandardModel.HiggsBoson.EffectivePotential +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic public import Physlib.Particles.StandardModel.HiggsBoson.Potential +public import Physlib.Particles.StandardModel.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.JetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.JetAlgebra.Invariants +public import Physlib.Particles.StandardModel.JetAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.JetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.JetAlgebra.MassDim +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Basic +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Prod +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Basic +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.MassDim +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Prod +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.IsCovStandardModel.Basic +public import Physlib.Particles.StandardModel.IsCovStandardModel.Generators +public import Physlib.Particles.StandardModel.IsCovStandardModel.MassWeight public import Physlib.Particles.StandardModel.Representations public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.B3 public import Physlib.Particles.SuperSymmetry.MSSMNu.AnomalyCancellation.Basic @@ -363,8 +425,11 @@ public import Physlib.Relativity.LorentzAlgebra.Basis public import Physlib.Relativity.LorentzAlgebra.ExponentialMap public import Physlib.Relativity.LorentzGroup.Basic public import Physlib.Relativity.LorentzGroup.Boosts.Apply +public import Physlib.Relativity.LorentzGroup.Boosts.Axis +public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading public import Physlib.Relativity.LorentzGroup.Boosts.Basic public import Physlib.Relativity.LorentzGroup.Boosts.Generalized +public import Physlib.Relativity.LorentzGroup.FermionicParity public import Physlib.Relativity.LorentzGroup.Orthochronous.Basic public import Physlib.Relativity.LorentzGroup.Proper public import Physlib.Relativity.LorentzGroup.Restricted.Basic @@ -378,6 +443,7 @@ public import Physlib.Relativity.PauliMatrices.CliffordAlgebra public import Physlib.Relativity.PauliMatrices.Relations public import Physlib.Relativity.PauliMatrices.SelfAdjoint public import Physlib.Relativity.PauliMatrices.ToTensor +public import Physlib.Relativity.SL2C.AxisRotations public import Physlib.Relativity.SL2C.Basic public import Physlib.Relativity.SL2C.SelfAdjoint public import Physlib.Relativity.Special.ProperTime diff --git a/Physlib/Mathematics/ConjModule.lean b/Physlib/Mathematics/ConjModule.lean index 3b2ce7039..9ff05c4a0 100644 --- a/Physlib/Mathematics/ConjModule.lean +++ b/Physlib/Mathematics/ConjModule.lean @@ -9,7 +9,8 @@ public import Mathlib.Algebra.Module.Equiv.Defs public import Mathlib.Algebra.Star.Module public import Mathlib.LinearAlgebra.Basis.Defs public import Mathlib.Tactic.Ring - +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Basic /-! # The conjugate module @@ -36,6 +37,7 @@ conjugate-linear identity `conjEquiv : M ≃ₛₗ[starRingEnd k] ConjModule M`, @[expose] public section open Module +open scoped TensorProduct variable {k : Type*} [CommRing k] [StarRing k] variable {M : Type*} [AddCommGroup M] [Module k M] @@ -53,6 +55,19 @@ conjugation ring endomorphism `starRingEnd k`. -/ instance instModule : Module k (ConjModule M) := Module.compHom M (starRingEnd k) +variable {A : Type*} [Ring A] + +instance : Ring (ConjModule A) := + let i1 : AddCommGroup (ConjModule A) := inferInstanceAs (AddCommGroup (ConjModule A)) + let i2 : Ring A := inferInstanceAs (Ring A) + { i1, i2 with } + +/-- The conjugate module of a `k`-algebra is a `k`-algebra: the same ring, with scalars +acting through `star`. -/ +instance instAlgebra [Algebra k A] : Algebra k (ConjModule A) := + Algebra.ofModule (fun r x y => smul_mul_assoc (β := A) (star r) x y) + (fun r x y => mul_smul_comm (β := A) (star r) x y) + end ConjModule /-- The canonical conjugate-linear equivalence `M ≃ₛₗ[starRingEnd k] ConjModule M`, the identity on @@ -65,6 +80,26 @@ def conjEquiv : M ≃ₛₗ[starRingEnd k] ConjModule M where left_inv _ := rfl right_inv _ := rfl +/-- The canonical conjugate-linear equivalence between the dual of a module `M` and + the dual of its conjugate. -/ +def conjDualEquiv : Module.Dual k M ≃ₛₗ[starRingEnd k] Module.Dual k (ConjModule M) where + toFun f := (starRingEnd k).toSemilinearMap.comp + (f.comp (conjEquiv (k := k) (M := M)).symm.toLinearMap) + invFun f := (starRingEnd k).toSemilinearMap.comp + (f.comp (conjEquiv (k := k) (M := M)).toLinearMap) + map_add' f g := by + ext x + simp + map_smul' r f := by + ext x + simp + left_inv f := by + ext x + simp + right_inv f := by + ext x + simp + namespace ConjModule /-- Conjugating twice returns the original module: the `k`-linear isomorphism @@ -89,16 +124,16 @@ noncomputable def starFinsupp : (ι →₀ k) ≃ₛₗ[starRingEnd k] (ι → /-- A basis of `M` transported to a basis of `ConjModule M`: the same basis vectors, with coordinates conjugated (`(Basis.conj b).repr v = star ∘ b.repr v`). -/ -noncomputable def _root_.Basis.conj (b : Basis ι k M) : Basis ι k (ConjModule M) := +noncomputable def _root_.Module.Basis.conj (b : Basis ι k M) : Basis ι k (ConjModule M) := Basis.ofRepr (((conjEquiv (k := k) (M := M)).symm.trans b.repr).trans starFinsupp) /-- Coordinates in `Basis.conj b` are the `star` of the coordinates in `b`. -/ -@[simp] lemma _root_.Basis.conj_repr_apply (b : Basis ι k M) (v : ConjModule M) (i : ι) : +@[simp] lemma _root_.Module.Basis.conj_repr_apply (b : Basis ι k M) (v : ConjModule M) (i : ι) : (Basis.conj b).repr v i = star (b.repr ((conjEquiv (k := k) (M := M)).symm v) i) := rfl /-- The basis vectors of `Basis.conj b` are those of `b`, viewed through `conjEquiv`. -/ -@[simp] lemma _root_.Basis.conj_apply (b : Basis ι k M) (i : ι) : +@[simp] lemma _root_.Module.Basis.conj_apply (b : Basis ι k M) (i : ι) : Basis.conj b i = conjEquiv (k := k) (M := M) (b i) := by apply (Basis.conj b).repr.injective ext j @@ -106,6 +141,180 @@ noncomputable def _root_.Basis.conj (b : Basis ι k M) : Basis ι k (ConjModule · subst h; simp [Basis.conj_repr_apply] · simp [Basis.conj_repr_apply, Finsupp.single_eq_of_ne, h] +/-! + +## The conjugate of a representation + +-/ + +/-- The conjugate of a representation `ρ` of `G` on `M`: the same maps `ρ g`, acting on +`ConjModule M` through `conjEquiv`. -/ +def _root_.Representation.conj {G} [Group G] (ρ : Representation k G M) : + Representation k G (ConjModule M) where + toFun g := { + toFun := conjEquiv (k := k) (M := M) ∘ ρ g ∘ (conjEquiv (k := k) (M := M)).symm + map_add' x y := (ρ g).map_add x y + map_smul' a m := (ρ g).map_smul (star a) m } + map_one' := LinearMap.ext fun _ => + congrArg (conjEquiv (k := k)) (LinearMap.congr_fun (map_one ρ) _) + map_mul' g h := LinearMap.ext fun _ => + congrArg (conjEquiv (k := k)) (LinearMap.congr_fun (map_mul ρ g h) _) + +lemma _root_.Representation.conj_apply {G} [Group G] (ρ : Representation k G M) (g : G) + (m : ConjModule M) : + ρ.conj g m = conjEquiv (k := k) (M := M) (ρ g ((conjEquiv (k := k) (M := M)).symm m)) := rfl + +/-! + +## Functoriality, and conjugation of tensor products + +Conjugation is monoidal: `ConjModule M ⊗ ConjModule N ≃ ConjModule (M ⊗ N)`, the identity +on pure tensors. The map is honestly `k`-linear because the twist on each factor cancels +against the twist on the target. + +Everything below routes through `conjEquiv` rather than relying on definitional unfolding +of the `ConjModule` synonym. Writing `m ⊗ₜ n` for `m : ConjModule M` makes elaboration +pick the *twisted* module instances, landing in the wrong tensor product; converting +explicitly with `conjEquiv` fixes every instance by construction. + +-/ + +variable {N : Type*} [AddCommGroup N] [Module k N] + +/-- Functoriality of conjugation: a `k`-linear map induces a `k`-linear map of the +conjugate modules, given by the same underlying function. -/ +def map (f : M →ₗ[k] N) : ConjModule M →ₗ[k] ConjModule N where + toFun := f + map_add' := f.map_add + map_smul' c x := f.map_smul (star c) x + +@[simp] +lemma map_apply (f : M →ₗ[k] N) (x : ConjModule M) : map f x = f x := rfl + +/-- **Conjugation commutes with finite products.** The conjugate of a product is the product +of the conjugates, by the identity underlying function: the twisted scalar action is applied +componentwise. -/ +def prodEquiv : ConjModule (M × N) ≃ₗ[k] ConjModule M × ConjModule N where + toFun x := (map (LinearMap.fst k M N) x, map (LinearMap.snd k M N) x) + map_add' _ _ := rfl + map_smul' _ _ := rfl + invFun x := (x.1, x.2) + left_inv _ := rfl + right_inv _ := rfl + +@[simp] +lemma prodEquiv_apply (x : ConjModule (M × N)) : + prodEquiv (k := k) x = (map (LinearMap.fst k M N) x, map (LinearMap.snd k M N) x) := rfl + +/-- The conjugate module of a finite free module is finite: the conjugated basis +`Module.Basis.conj` is indexed by the same type. -/ +instance instFinite [Module.Free k M] [Module.Finite k M] : + Module.Finite k (ConjModule M) := + Module.Finite.of_basis (Module.Basis.conj (Module.Free.chooseBasis k M)) + +/-- The canonical `k`-linear map `ConjModule M ⊗ ConjModule N → ConjModule (M ⊗ N)`, +the identity on pure tensors. -/ +noncomputable def tensorHom : ConjModule M ⊗[k] ConjModule N →ₗ[k] ConjModule (M ⊗[k] N) := + TensorProduct.lift + { toFun := fun m => + { toFun := fun n => conjEquiv (k := k) (M := M ⊗[k] N) + ((conjEquiv (k := k) (M := M)).symm m ⊗ₜ[k] (conjEquiv (k := k) (M := N)).symm n) + map_add' := by + intro n₁ n₂ + rw [map_add, TensorProduct.tmul_add, map_add] + map_smul' := by + intro c n + rw [map_smulₛₗ, TensorProduct.tmul_smul, map_smulₛₗ] + simp } + map_add' := by + intro m₁ m₂ + ext n + simp only [LinearMap.coe_mk, AddHom.coe_mk, LinearMap.add_apply] + rw [map_add, TensorProduct.add_tmul, map_add] + map_smul' := by + intro c m + ext n + simp only [LinearMap.coe_mk, AddHom.coe_mk, LinearMap.smul_apply, RingHom.id_apply] + rw [map_smulₛₗ, ← TensorProduct.smul_tmul', map_smulₛₗ] + simp } + +@[simp] +lemma tensorHom_tmul (m : ConjModule M) (n : ConjModule N) : + tensorHom (k := k) (m ⊗ₜ[k] n) + = conjEquiv (k := k) (M := M ⊗[k] N) + ((conjEquiv (k := k) (M := M)).symm m ⊗ₜ[k] (conjEquiv (k := k) (M := N)).symm n) := + rfl + +/-- The inverse map `ConjModule (M ⊗ N) → ConjModule M ⊗ ConjModule N`, again the identity +on pure tensors. A `k`-linear map out of `ConjModule X` is the same data as a `k`-linear +map into `ConjModule` of the target, which is what `map` and `involution` package here. -/ +noncomputable def tensorInv : ConjModule (M ⊗[k] N) →ₗ[k] ConjModule M ⊗[k] ConjModule N := + (involution (k := k) (M := ConjModule M ⊗[k] ConjModule N)).toLinearMap ∘ₗ + map (TensorProduct.lift + { toFun := fun m => + { toFun := fun n => conjEquiv (k := k) (M := ConjModule M ⊗[k] ConjModule N) + (conjEquiv (k := k) (M := M) m ⊗ₜ[k] conjEquiv (k := k) (M := N) n) + map_add' := by + intro n₁ n₂ + rw [map_add, TensorProduct.tmul_add, map_add] + map_smul' := by + intro c n + rw [map_smulₛₗ, TensorProduct.tmul_smul, map_smulₛₗ] + simp } + map_add' := by + intro m₁ m₂ + ext n + simp only [LinearMap.coe_mk, AddHom.coe_mk, LinearMap.add_apply] + rw [map_add, TensorProduct.add_tmul, map_add] + map_smul' := by + intro c m + ext n + simp only [LinearMap.coe_mk, AddHom.coe_mk, LinearMap.smul_apply, RingHom.id_apply] + rw [map_smulₛₗ, ← TensorProduct.smul_tmul', map_smulₛₗ] + simp }) + +/-- **Conjugation is monoidal.** `ConjModule M ⊗ ConjModule N ≃ₗ[k] ConjModule (M ⊗ N)`, +the identity on pure tensors. Injectivity comes from `tensorInv` being a left inverse; +surjectivity from every element of `M ⊗ N` being a sum of pure tensors. -/ +noncomputable def tensorEquiv : + ConjModule M ⊗[k] ConjModule N ≃ₗ[k] ConjModule (M ⊗[k] N) := + LinearEquiv.ofBijective tensorHom + ⟨by + have h : ∀ w : ConjModule M ⊗[k] ConjModule N, tensorInv (tensorHom w) = w := by + intro w + induction w using TensorProduct.induction_on with + | zero => simp + | tmul m n => rfl + | add x y hx hy => rw [map_add, map_add, hx, hy] + exact Function.LeftInverse.injective h, + by + intro z + induction z using TensorProduct.induction_on with + | zero => exact ⟨0, map_zero _⟩ + | tmul m n => + exact ⟨conjEquiv (k := k) (M := M) m ⊗ₜ[k] conjEquiv (k := k) (M := N) n, rfl⟩ + | add x y hx hy => + obtain ⟨w₁, h₁⟩ := hx + obtain ⟨w₂, h₂⟩ := hy + refine ⟨w₁ + w₂, ?_⟩ + rw [map_add, h₁, h₂] + rfl⟩ + +@[simp] +lemma tensorEquiv_tmul (m : ConjModule M) (n : ConjModule N) : + tensorEquiv (k := k) (m ⊗ₜ[k] n) + = conjEquiv (k := k) (M := M ⊗[k] N) + ((conjEquiv (k := k) (M := M)).symm m ⊗ₜ[k] (conjEquiv (k := k) (M := N)).symm n) := + rfl + +@[simp] +lemma tensorEquiv_symm_conjEquiv_tmul (m : M) (n : N) : + (tensorEquiv (k := k) (M := M) (N := N)).symm + (conjEquiv (k := k) (M := M ⊗[k] N) (m ⊗ₜ[k] n)) + = conjEquiv (k := k) (M := M) m ⊗ₜ[k] conjEquiv (k := k) (M := N) n := by + rw [LinearEquiv.symm_apply_eq, tensorEquiv_tmul] + simp + end ConjModule end diff --git a/Physlib/Mathematics/MvPolynomialTranslation.lean b/Physlib/Mathematics/MvPolynomialTranslation.lean new file mode 100644 index 000000000..4bb37e451 --- /dev/null +++ b/Physlib/Mathematics/MvPolynomialTranslation.lean @@ -0,0 +1,156 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Mathlib.Algebra.MvPolynomial.Funext +public import Mathlib.Algebra.MvPolynomial.Monad +public import Mathlib.Algebra.MvPolynomial.Supported +/-! +# Polynomials invariant under fiberwise translations of variables + +Let `π` be an idempotent map on the index type of a multivariate polynomial ring +over an infinite integral domain, thought of as assigning to each variable a +canonical representative of its fiber. A polynomial that is invariant under +simultaneously translating, for each fiber, all the variables in that fiber by a +common constant is a polynomial in the differences `X i - X (π i)`. + +This is the algebraic heart of the statement that the gauge-invariant elements of +the jet algebra of an abelian gauge boson are generated by the derivatives of the +field strength: the Maurer–Cartan shift translates all jet coordinates with the +same symmetrized multi-index by a common amount, and the differences of such +coordinates are the derivatives of the field strength. + +-/ + +@[expose] public section + +namespace MvPolynomial + +variable {R : Type*} [CommRing R] [IsDomain R] [Infinite R] +variable {I : Type*} [DecidableEq I] + +omit [IsDomain R] [Infinite R] [DecidableEq I] in +/-- Evaluation of a substitution of a multivariate polynomial: substitution followed + by evaluation is evaluation at the evaluated substituents. -/ +lemma eval_aeval (x : I → R) (g : I → MvPolynomial I R) (p : MvPolynomial I R) : + eval x (aeval g p) = eval (fun i => eval x (g i)) p := by + induction p using MvPolynomial.induction_on with + | C a => simp + | add p q hp hq => simp only [map_add, hp, hq] + | mul_X p i hp => simp only [map_mul, aeval_X, hp, eval_X] + +/-- A polynomial invariant under all translations of a fixed variable is unchanged + by setting that variable to zero. -/ +lemma aeval_update_zero_eq_of_forall_aeval_add_eq (Q : MvPolynomial I R) (j : I) + (hQ : ∀ r : R, aeval (fun i => X i + C (if i = j then r else 0)) Q = Q) : + aeval (fun i => if i = j then 0 else X i) Q = Q := by + refine MvPolynomial.funext fun x => ?_ + have h := congrArg (eval x) (hQ (-(x j))) + rw [eval_aeval] at h + rw [eval_aeval] + have hpt : (fun i => eval x ((if i = j then 0 else X i) : MvPolynomial I R)) = + fun i => eval x (X i + C (if i = j then -(x j) else 0)) := by + funext i + by_cases hi : i = j + · simp [hi] + · simp [hi] + rw [hpt] + exact h + +/-- A polynomial invariant under all translations of a fixed variable does not + involve that variable. -/ +lemma notMem_vars_of_forall_aeval_add_eq (Q : MvPolynomial I R) (j : I) + (hQ : ∀ r : R, aeval (fun i => X i + C (if i = j then r else 0)) Q = Q) : + j ∉ Q.vars := by + intro hjv + have h2 := vars_bind₁ (fun i => if i = j then 0 else X i) Q + (by rw [show bind₁ (fun i => if i = j then (0 : MvPolynomial I R) else X i) Q = + aeval (fun i => if i = j then 0 else X i) Q from rfl, + aeval_update_zero_eq_of_forall_aeval_add_eq Q j hQ] + exact hjv) + obtain ⟨i, hiQ, hji⟩ := Finset.mem_biUnion.mp h2 + by_cases hij : i = j + · rw [if_pos hij, vars_0] at hji + simp at hji + · rw [if_neg hij, vars_X] at hji + exact hij (Finset.mem_singleton.mp hji).symm + +/-- A multivariate polynomial over an infinite integral domain that is invariant + under simultaneously translating, for every fiber of an idempotent map `π` on the + variables, all the variables in that fiber by a common constant, is a polynomial + in the differences `X i - X (π i)`. -/ +theorem mem_adjoin_range_X_sub_X_of_forall_aeval_add_eq (π : I → I) + (hπ : ∀ i, π (π i) = π i) (P : MvPolynomial I R) + (hP : ∀ (i₀ : I) (r : R), + aeval (fun i => X i + C (if π i = π i₀ then r else 0)) P = P) : + P ∈ Algebra.adjoin R (Set.range fun i => (X i - X (π i) : MvPolynomial I R)) := by + have hcompHom : (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i - X (π i))).comp + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) else X i + X (π i))) = + AlgHom.id R (MvPolynomial I R) := by + apply algHom_ext + intro i + simp only [AlgHom.comp_apply, aeval_X, AlgHom.id_apply] + by_cases hi : π i = i + · rw [if_pos hi, aeval_X, if_pos hi] + · rw [if_neg hi, map_add, aeval_X, aeval_X, if_neg hi, if_pos (hπ i)] + ring + have hcomp : ∀ p : MvPolynomial I R, + aeval (fun i => if π i = i then (X i : MvPolynomial I R) else X i - X (π i)) + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i)) p) = p := by + intro p + have h := DFunLike.congr_fun hcompHom p + simpa using h + have hQtrans : ∀ (j : I), π j = j → ∀ (r : R), + aeval (fun i => (X i + C (if i = j then r else 0) : MvPolynomial I R)) + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i)) P) = + aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i)) P := by + intro j hj r + have hkey : (aeval (fun i => X i + C (if i = j then r else 0))).comp + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i))) = + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i))).comp + (aeval (fun i => X i + C (if π i = π j then r else 0))) := by + apply algHom_ext + intro i + simp only [AlgHom.comp_apply, aeval_X] + by_cases hi : π i = i + · rw [if_pos hi] + simp only [map_add, aeval_X, aeval_C, algebraMap_eq] + rw [if_pos hi, if_congr (show (i = j) ↔ (π i = π j) from + ⟨fun h => by rw [h], fun h => by rw [← hi, h, hj]⟩) rfl rfl] + · rw [if_neg hi] + simp only [map_add, aeval_X, aeval_C, algebraMap_eq] + rw [if_neg hi, if_neg (show ¬i = j from fun h => hi (by rw [h, hj])), + if_congr (show (π i = j) ↔ (π i = π j) from by rw [hj]) rfl rfl, C_0] + ring + have h1 := DFunLike.congr_fun hkey P + simp only [AlgHom.comp_apply] at h1 + rw [hP j r] at h1 + exact h1 + have hQsupp : aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i + X (π i)) P ∈ + supported R {i : I | π i ≠ i} := by + refine mem_supported.mpr fun j hj => ?_ + intro hjfix + exact notMem_vars_of_forall_aeval_add_eq _ j (hQtrans j hjfix) (Finset.mem_coe.mp hj) + rw [supported_eq_adjoin_X] at hQsupp + have hmem : P ∈ (Algebra.adjoin R (X '' {i : I | π i ≠ i})).map + (aeval (fun i => if π i = i then (X i : MvPolynomial I R) + else X i - X (π i))) := + Subalgebra.mem_map.mpr ⟨_, hQsupp, hcomp P⟩ + rw [AlgHom.map_adjoin] at hmem + refine Algebra.adjoin_mono ?_ hmem + rintro _ ⟨_, ⟨i, hi, rfl⟩, rfl⟩ + refine ⟨i, ?_⟩ + simp only [aeval_X] + rw [if_neg (Set.mem_setOf.mp hi)] + +end MvPolynomial diff --git a/Physlib/Mathematics/MvPowerSeriesDerivative.lean b/Physlib/Mathematics/MvPowerSeriesDerivative.lean new file mode 100644 index 000000000..aac68f943 --- /dev/null +++ b/Physlib/Mathematics/MvPowerSeriesDerivative.lean @@ -0,0 +1,214 @@ +/- +Copyright (c) 2026 Justus Springer. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Justus Springer +-/ +module + +public import Mathlib.Algebra.MvPolynomial.PDeriv +public import Mathlib.RingTheory.MvPowerSeries.Inverse +public import Mathlib.RingTheory.MvPowerSeries.Trunc + +/-! +# Formal partial derivatives of multivariate power series + +NOTE: This file is copied verbatim from `Mathlib.RingTheory.MvPowerSeries.Derivative` +(mathlib4 commit `9fb10993c11c9e7abfa291e86fb499b6e1f4da82`), which postdates the Mathlib +version currently pinned by this project. Delete this copy and import the Mathlib file +directly once the pin catches up. + +This file defines `MvPowerSeries.pderiv R i`, the formal partial derivative of a multivariate +power series with respect to variable `i`, as a +`Derivation R (MvPowerSeries σ R) (MvPowerSeries σ R)`. + +See also `PowerSeries.derivative` for the univariate setting. + +## Main definitions + +- `MvPowerSeries.pderiv R i`: the formal partial derivative with respect to `i`, as a derivation. + +## Main results + +- `MvPowerSeries.coeff_pderiv`: coefficient formula + `coeff n (pderiv R i f) = coeff (n + single i 1) f * (n i + 1)`. +- `MvPowerSeries.pderiv_coe`: compatibility with `MvPolynomial.pderiv`. +- `MvPowerSeries.trunc_pderiv`: truncation commutes with partial differentiation. +- `MvPowerSeries.pderiv.ext`: a power series is determined by its constant term and its partial + derivatives. +- `MvPowerSeries.pderiv_pow`: power rule. +- `MvPowerSeries.pderiv_inv`, `MvPowerSeries.pderiv_inv'`: derivative of an inverse. + +-/ + +@[expose] public section + +namespace MvPowerSeries + +open MvPolynomial Finsupp + +variable {σ R : Type*} + +section Semiring + +variable [Semiring R] + +/-- The underlying function of the formal partial derivative with respect to variable `i`. +This is packaged as a derivation in `MvPowerSeries.pderiv`. -/ +noncomputable def pderivFun (i : σ) (f : MvPowerSeries σ R) : MvPowerSeries σ R := + fun d ↦ coeff (d + single i 1) f * (d i + 1) + +theorem coeff_pderivFun {i : σ} (f : MvPowerSeries σ R) (d : σ →₀ ℕ) : + coeff d (f.pderivFun i) = coeff (d + single i 1) f * (d i + 1) := by + rfl + +theorem pderivFun_add {i : σ} (f g : MvPowerSeries σ R) : + pderivFun i (f + g) = pderivFun i f + pderivFun i g := by + ext + rw [coeff_pderivFun, map_add, map_add, coeff_pderivFun, coeff_pderivFun, add_mul] + +theorem pderivFun_C {i : σ} (r : R) : pderivFun i (C r) = 0 := by + ext n + rw [coeff_pderivFun, coeff_add_single_C, zero_mul, (coeff n).map_zero] + +theorem pderivFun_one {i : σ} : pderivFun i (1 : MvPowerSeries σ R) = 0 := by + rw [← map_one C, pderivFun_C (1 : R)] + +end Semiring + +section CommSemiring + +variable [CommSemiring R] + +private theorem pderivFun_coe {i : σ} (f : MvPolynomial σ R) : + (f : MvPowerSeries σ R).pderivFun i = f.pderiv i := by + ext + rw [coeff_pderivFun, coeff_coe, coeff_coe, coeff_pderiv] + +private theorem trunc_pderivFun [DecidableEq σ] {i : σ} (f : MvPowerSeries σ R) (n : σ →₀ ℕ) : + trunc R n (pderivFun i f) = pderiv i (trunc R (n + single i 1) f) := by + ext + rw [coeff_trunc] + split_ifs with h + · rw [coeff_pderivFun, coeff_pderiv, coeff_trunc, if_pos (add_lt_add_left h _)] + · rw [coeff_pderiv, coeff_trunc, if_neg ((add_lt_add_iff_right _).not.mpr h), zero_mul] + +-- A special case of `pderivFun_mul`, used in its proof. +private theorem pderivFun_coe_mul_coe {i : σ} (f g : MvPolynomial σ R) : + pderivFun i (f * g : MvPowerSeries σ R) = f * pderiv i g + g * pderiv i f := by + rw [← coe_mul, pderivFun_coe, pderiv_mul, add_comm, mul_comm _ g, ← coe_mul, ← coe_mul, + MvPolynomial.coe_add] + +private theorem pderivFun_mul {i : σ} (f g : MvPowerSeries σ R) : + pderivFun i (f * g) = f • g.pderivFun i + g • f.pderivFun i := by + classical + ext n + have h₁ : n < n + single i 1 := lt_def.mpr ⟨self_le_add_right _ _, i, by simp⟩ + have h₂ : n + single i 1 < n + single i 1 + single i 1 := + lt_def.mpr ⟨self_le_add_right _ _, i, by simp⟩ + have h₃ : n < n + single i 1 + single i 1 := lt_trans h₁ h₂ + rw [coeff_pderivFun, map_add, ← coeff_trunc_mul_trunc_eq_coeff_mul _ _ _ h₂, smul_eq_mul, + smul_eq_mul, ← coeff_trunc_mul_trunc_eq_coeff_mul₂ _ _ g (f.pderivFun i) h₃ h₁, + ← coeff_trunc_mul_trunc_eq_coeff_mul₂ _ _ f (g.pderivFun i) h₃ h₁, trunc_pderivFun, + trunc_pderivFun, ← coeff_coe, ← coeff_coe, ← coeff_coe, ← map_add, coe_mul, coe_mul, coe_mul, + ← pderivFun_coe_mul_coe, coeff_pderivFun] + +private theorem pderivFun_smul {i : σ} (r : R) (f : MvPowerSeries σ R) : + pderivFun i (r • f) = r • pderivFun i f := by + rw [smul_eq_C_mul, smul_eq_C_mul, pderivFun_mul, pderivFun_C, smul_zero, add_zero, smul_eq_mul] + +variable (R) in +/-- The formal partial derivative of a multivariate formal power series with respect to +variable `i`, as an `R`-derivation on `MvPowerSeries σ R`. -/ +@[no_expose] +noncomputable def pderiv (i : σ) : Derivation R (MvPowerSeries σ R) (MvPowerSeries σ R) where + toFun := pderivFun i + map_add' := pderivFun_add + map_smul' := pderivFun_smul + map_one_eq_zero' := pderivFun_one + leibniz' := pderivFun_mul + +@[simp] theorem pderiv_C {i : σ} {r : R} : pderiv R i (C r) = 0 := pderivFun_C r + +theorem pderiv_one {i : σ} : pderiv R i 1 = 0 := pderiv_C + +theorem coeff_pderiv {i : σ} (f : MvPowerSeries σ R) (n : σ →₀ ℕ) : + coeff n (pderiv R i f) = coeff (n + single i 1) f * (n i + 1) := + coeff_pderivFun f n + +theorem pderiv_coe {i : σ} (f : MvPolynomial σ R) : + pderiv R i f = MvPolynomial.pderiv i f := pderivFun_coe f + +@[simp] +theorem pderiv_X_self {i : σ} : pderiv R i (X i) = 1 := by + classical + ext n + simp only [coeff_pderiv, coeff_X, boole_mul, add_eq_right, coeff_one] + split_ifs <;> simp_all + +@[simp] +theorem pderiv_X_of_ne {i j : σ} (h : j ≠ i) : pderiv R i (X j) = 0 := by + classical + ext n + simpa only [coeff_pderiv, coeff_X, boole_mul, coeff_zero] using + if_neg (ne_iff.mpr ⟨i, by grind [Finsupp.add_apply]⟩) + +theorem pderiv_X [DecidableEq σ] (i j : σ) : + pderiv R i (X j) = Pi.single (M := fun _ => MvPowerSeries σ R) i 1 j := by + by_cases h : i = j + · subst h; simp only [pderiv_X_self, Pi.single_eq_same] + · grind [pderiv_X_of_ne] + +theorem trunc_pderiv [DecidableEq σ] {i : σ} (f : MvPowerSeries σ R) (n : σ →₀ ℕ) : + trunc R n (pderiv R i f) = MvPolynomial.pderiv i (trunc R (n + single i 1) f) := + trunc_pderivFun .. + +/-- The partial derivative of `g^n` equals `n * g^(n-1) * g'`. -/ +theorem pderiv_pow {i : σ} (g : MvPowerSeries σ R) (n : ℕ) : + pderiv R i (g ^ n) = n * g ^ (n - 1) * pderiv R i g := by + rw [Derivation.leibniz_pow, smul_eq_mul, nsmul_eq_mul, mul_assoc] + +end CommSemiring + +/-- If `f` and `g` have the same constant term and all partial derivatives, then they are equal. + +The `CommRing` assumption is needed because the proof uses `smul_right_inj`, which requires +cancellation of addition in `R`; `IsAddTorsionFree` alone does not suffice. -/ +theorem pderiv.ext [CommRing R] [IsAddTorsionFree R] {f g : MvPowerSeries σ R} + (hD : ∀ i, pderiv R i f = pderiv R i g) (hc : constantCoeff f = constantCoeff g) : f = g := by + ext n + by_cases h : n = 0 + · rw [h, coeff_zero_eq_constantCoeff, hc] + obtain ⟨i, hi : n i ≠ 0⟩ := ne_iff.mp h + have : single i 1 ≤ n := fun j ↦ by + by_cases hj : j = i <;> grind [single_eq_same, single_eq_of_ne] + have e := congr(coeff (n - single i 1) $(hD i)) + rwa [coeff_pderiv, coeff_pderiv, tsub_add_cancel_of_le this, coe_tsub, Pi.sub_apply, + single_eq_same, Nat.cast_sub (Nat.one_le_iff_ne_zero.mpr hi), Nat.cast_one, sub_add_cancel, + mul_comm, ← nsmul_eq_mul, mul_comm, ← nsmul_eq_mul, smul_right_inj hi] at e + +@[simp] +theorem pderiv_inv {i : σ} [CommRing R] (f : (MvPowerSeries σ R)ˣ) : + pderiv R i ↑f⁻¹ = -(↑f⁻¹ : MvPowerSeries σ R) ^ 2 * pderiv R i f := + (pderiv R i).leibniz_of_mul_eq_one f.inv_mul + +@[simp] +theorem pderiv_invOf {i : σ} [CommRing R] (f : MvPowerSeries σ R) [Invertible f] : + pderiv R i ⅟f = -⅟f ^ 2 * pderiv R i f := + (pderiv R i).leibniz_invOf f + +/- +The following theorem is stated only in the case that `R` is a field. This is because +there is currently no instance of `Inv (MvPowerSeries σ R)` for more general base rings `R`. +-/ + +@[simp] +theorem pderiv_inv' {i : σ} [Field R] (f : MvPowerSeries σ R) : + pderiv R i f⁻¹ = -f⁻¹ ^ 2 * pderiv R i f := by + by_cases h : constantCoeff f = 0 + · suffices f⁻¹ = 0 by + rw [this, pow_two, zero_mul, neg_zero, zero_mul, map_zero] + rwa [MvPowerSeries.inv_eq_zero] + apply Derivation.leibniz_of_mul_eq_one + exact MvPowerSeries.inv_mul_cancel (h := h) + +end MvPowerSeries diff --git a/Physlib/Mathematics/PolynomialEval.lean b/Physlib/Mathematics/PolynomialEval.lean new file mode 100644 index 000000000..d7972186b --- /dev/null +++ b/Physlib/Mathematics/PolynomialEval.lean @@ -0,0 +1,197 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Mathlib.LinearAlgebra.Dual.Lemmas +public import Mathlib.Algebra.Polynomial.AlgebraMap +public import Mathlib.Algebra.Polynomial.Roots +/-! + +# Polynomials with coefficients in an algebra + +## i. Overview + +A polynomial whose coefficients lie in a `k`-algebra `A` can be evaluated at the image +`algebraMap k A c` of a scalar. This file records that such a polynomial is determined by +those evaluations alone, when `k` is an infinite field, and defines the polynomial obtained +by applying a `k`-linear map to every coefficient. + +Both are used to transport grading statements between two equivalent descriptions of a +grading on a jet algebra: the *mass-weight polynomial*, whose `X ^ n` coefficient is the +weight-`n` part of an element, and the *mass-weight scaling*, the algebra map scaling each +weight-`n` part by `c ^ n`. The scaling is the evaluation of the polynomial, so a statement +about one transfers to the other. + +The determinacy is not an instance of `Polynomial.funext`: the coefficient ring `A` is +neither commutative nor a domain in the intended applications. It holds because `A` is a +`k`-vector space, so its elements are separated by linear functionals, and a polynomial over +the infinite field `k` is determined by its values. + +## ii. Key results + +- `Polynomial.eq_zero_of_forall_eval_algebraMap_eq_zero` : a polynomial vanishing at every + scalar is zero. +- `Polynomial.ext_of_forall_eval_algebraMap` : two polynomials agreeing at every scalar are + equal. +- `Polynomial.mapCoeffs` : apply a linear map to every coefficient. +- `Polynomial.eval_algebraMap_mapCoeffs` : evaluation commutes with `mapCoeffs`. + +## iii. Table of contents + +- A. Determinacy by evaluation at scalars +- B. Applying a linear map to the coefficients + +-/ + +@[expose] public section + +namespace Polynomial + +/-! + +## A. Determinacy by evaluation at scalars + +-/ + +/-- A polynomial with coefficients in an algebra over an infinite field vanishes as soon as + it vanishes at the image of every scalar. Linear functionals separate the coefficients, + and over an infinite field a polynomial is determined by its values. -/ +lemma eq_zero_of_forall_eval_algebraMap_eq_zero {k A : Type*} [Field k] [Infinite k] + [Ring A] [Algebra k A] {p : Polynomial A} + (h : ∀ c : k, p.eval (algebraMap k A c) = 0) : p = 0 := by + ext n + rw [Polynomial.coeff_zero, ← Module.forall_dual_apply_eq_zero_iff k] + intro φ + set s : Polynomial k := ∑ m ∈ p.support, Polynomial.monomial m (φ (p.coeff m)) with hs + have hcoeff : ∀ m, s.coeff m = φ (p.coeff m) := by + intro m + rw [hs, Polynomial.finsetSum_coeff] + simp only [Polynomial.coeff_monomial] + rw [Finset.sum_ite_eq' p.support m fun i => φ (p.coeff i)] + by_cases hm : m ∈ p.support + · rw [if_pos hm] + · rw [if_neg hm, Polynomial.notMem_support_iff.mp hm, map_zero] + have hzero : s = 0 := by + refine Polynomial.funext fun c => ?_ + have h1 := congrArg φ (h c) + rw [Polynomial.eval_eq_sum, Polynomial.sum_def, map_sum, map_zero] at h1 + rw [Polynomial.eval_zero, hs, Polynomial.eval_finsetSum] + simp only [Polynomial.eval_monomial] + rw [← h1] + refine Finset.sum_congr rfl fun m _ => ?_ + rw [← map_pow, ← Algebra.commutes, ← Algebra.smul_def, map_smul, smul_eq_mul, mul_comm] + rw [← hcoeff n, hzero, Polynomial.coeff_zero] + +/-- Two polynomials with coefficients in an algebra over an infinite field are equal as soon + as they agree at the image of every scalar. -/ +lemma ext_of_forall_eval_algebraMap {k A : Type*} [Field k] [Infinite k] + [Ring A] [Algebra k A] {p q : Polynomial A} + (h : ∀ c : k, p.eval (algebraMap k A c) = q.eval (algebraMap k A c)) : p = q := by + rw [← sub_eq_zero] + refine eq_zero_of_forall_eval_algebraMap_eq_zero (k := k) fun c => ?_ + rw [Polynomial.eval_sub, h c, sub_self] + +/-! + +## B. Applying a linear map to the coefficients + +-/ + +/-- The polynomial obtained by applying a function to every coefficient. Unlike + `Polynomial.map` this needs no multiplicativity, so it applies to derivations. + + The argument is a bare function rather than a linear map: on an algebra built as a tensor + product the module structure coming from the algebra and the one coming from the tensor + product are equal but not syntactically so, and bundling would force the caller to + reconcile them. The properties needed are taken as hypotheses instead. -/ +noncomputable def mapCoeffs {A : Type*} [Semiring A] (f : A → A) (p : Polynomial A) : + Polynomial A := + ∑ m ∈ p.support, Polynomial.monomial m (f (p.coeff m)) + +lemma coeff_mapCoeffs {A : Type*} [Semiring A] {f : A → A} (hf0 : f 0 = 0) + (p : Polynomial A) (n : ℕ) : (mapCoeffs f p).coeff n = f (p.coeff n) := by + rw [mapCoeffs, Polynomial.finsetSum_coeff] + simp only [Polynomial.coeff_monomial] + rw [Finset.sum_ite_eq' p.support n fun i => f (p.coeff i)] + by_cases hn : n ∈ p.support + · rw [if_pos hn] + · rw [if_neg hn, Polynomial.notMem_support_iff.mp hn, hf0] + +@[simp] +lemma mapCoeffs_zero {A : Type*} [Semiring A] (f : A → A) : mapCoeffs f 0 = 0 := by + simp [mapCoeffs] + +lemma mapCoeffs_monomial {A : Type*} [Semiring A] {f : A → A} (hf0 : f 0 = 0) + (n : ℕ) (a : A) : + mapCoeffs f (Polynomial.monomial n a) = Polynomial.monomial n (f a) := by + ext m + rw [coeff_mapCoeffs hf0, Polynomial.coeff_monomial, Polynomial.coeff_monomial] + split_ifs + · rfl + · exact hf0 + +lemma mapCoeffs_add {A : Type*} [Semiring A] {f : A → A} (hf0 : f 0 = 0) + (hadd : ∀ a b : A, f (a + b) = f a + f b) (p q : Polynomial A) : + mapCoeffs f (p + q) = mapCoeffs f p + mapCoeffs f q := by + ext m + rw [coeff_mapCoeffs hf0, Polynomial.coeff_add, Polynomial.coeff_add, coeff_mapCoeffs hf0, + coeff_mapCoeffs hf0, hadd] + +/-- Evaluation at a scalar commutes with pushing a polynomial along an algebra map: an + algebra map fixes the scalars. -/ +lemma eval_algebraMap_mapAlgHom {k A B : Type*} [CommSemiring k] [Semiring A] [Semiring B] + [Algebra k A] [Algebra k B] (f : A →ₐ[k] B) (p : Polynomial A) (c : k) : + (Polynomial.mapAlgHom f p).eval (algebraMap k B c) = f (p.eval (algebraMap k A c)) := by + induction p using Polynomial.induction_on' with + | add p q hp hq => rw [map_add, Polynomial.eval_add, Polynomial.eval_add, hp, hq, map_add] + | monomial n a => + simp only [Polynomial.mapAlgHom, AlgHom.coe_mk, Polynomial.coe_mapRingHom, + Polynomial.map_monomial] + rw [Polynomial.eval_monomial, Polynomial.eval_monomial, map_mul, map_pow, + AlgHom.commutes] + rfl + +/-- Evaluation at a scalar commutes with applying a linear map to the coefficients: the + powers of the scalar are central, so they pass through the linear map. -/ +lemma eval_algebraMap_mapCoeffs {k A : Type*} [Field k] [Ring A] [Algebra k A] + (f : A →ₗ[k] A) (p : Polynomial A) (c : k) : + (mapCoeffs f p).eval (algebraMap k A c) = f (p.eval (algebraMap k A c)) := by + have hsmul : ∀ (m : ℕ) (a : A), a * (algebraMap k A c) ^ m = (c ^ m) • a := fun m a => by + rw [← map_pow, ← Algebra.commutes, ← Algebra.smul_def] + induction p using Polynomial.induction_on' with + | add p q hp hq => + rw [mapCoeffs_add (map_zero f) (map_add f), Polynomial.eval_add, Polynomial.eval_add, + hp, hq, map_add] + | monomial n a => + rw [mapCoeffs_monomial (map_zero f), Polynomial.eval_monomial, Polynomial.eval_monomial, + hsmul, hsmul, map_smul] + +/-- Evaluation at one commutes with pushing a polynomial along an algebra map. -/ +lemma eval_one_mapAlgHom {k A B : Type*} [CommSemiring k] [Semiring A] [Semiring B] + [Algebra k A] [Algebra k B] (f : A →ₐ[k] B) (p : Polynomial A) : + (Polynomial.mapAlgHom f p).eval 1 = f (p.eval 1) := by + have h := eval_algebraMap_mapAlgHom f p 1 + rwa [map_one, map_one] at h + +/-- A map satisfying the Leibniz rule satisfies it coefficientwise on polynomials. Applied to + a total derivative this is the Leibniz rule for the mass-weight polynomial. -/ +lemma mapCoeffs_mul_of_leibniz {A : Type*} [Ring A] {D : A → A} (hD0 : D 0 = 0) + (hDadd : ∀ a b : A, D (a + b) = D a + D b) + (hD : ∀ a b : A, D (a * b) = D a * b + a * D b) (p q : Polynomial A) : + mapCoeffs D (p * q) = mapCoeffs D p * q + p * mapCoeffs D q := by + have hsum : ∀ (s : Finset (ℕ × ℕ)) (g : ℕ × ℕ → A), + D (∑ m ∈ s, g m) = ∑ m ∈ s, D (g m) := by + intro s g + induction s using Finset.induction with + | empty => simpa using hD0 + | insert a s ha ih => rw [Finset.sum_insert ha, hDadd, ih, Finset.sum_insert ha] + ext n + rw [coeff_mapCoeffs hD0, Polynomial.coeff_add, Polynomial.coeff_mul, Polynomial.coeff_mul, + Polynomial.coeff_mul, hsum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun m _ => ?_ + rw [hD, coeff_mapCoeffs hD0, coeff_mapCoeffs hD0] + +end Polynomial diff --git a/Physlib/Mathematics/SymmetricAlgebra.lean b/Physlib/Mathematics/SymmetricAlgebra.lean new file mode 100644 index 000000000..b196e6c54 --- /dev/null +++ b/Physlib/Mathematics/SymmetricAlgebra.lean @@ -0,0 +1,258 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.RingTheory.TensorProduct.Maps +public import Mathlib.Algebra.TrivSqZeroExt.Basic +/-! +# Functoriality of the symmetric algebra + +## i. Overview + +Mathlib's `SymmetricAlgebra` carries the universal property `SymmetricAlgebra.lift` but no +functorial API. This file provides it: the algebra homomorphism induced by a linear map, the +algebra equivalence induced by a linear equivalence, generation by the degree-one elements, +and the decomposition of the symmetric algebra of a direct sum as a tensor product — the +bosonic analogue of `CliffordAlgebra.prodEquiv`, with the ordinary rather than the graded +tensor product because everything commutes. + +## ii. Key results + +- `SymmetricAlgebra.map` : the algebra homomorphism induced by a linear map. +- `SymmetricAlgebra.congr` : the algebra equivalence induced by a linear equivalence. +- `SymmetricAlgebra.adjoin_range_ι` : the symmetric algebra is generated by `ι`. +- `SymmetricAlgebra.prodEquiv` : the symmetric algebra of a direct sum is the tensor + product of the symmetric algebras. + +## iii. Table of contents + +- A. Functoriality of the symmetric algebra +- B. Generation by the degree-one elements +- C. The symmetric algebra of a direct sum +- D. The derivation extending a linear endomorphism + +-/ + +@[expose] public section + +namespace SymmetricAlgebra + +variable {R M N P : Type*} [CommRing R] [AddCommGroup M] [Module R M] + [AddCommGroup N] [Module R N] [AddCommGroup P] [Module R P] + +/-! + +## A. Functoriality of the symmetric algebra + +-/ + +/-- The algebra homomorphism between symmetric algebras induced by a linear map of the + underlying modules. -/ +def map (f : M →ₗ[R] N) : SymmetricAlgebra R M →ₐ[R] SymmetricAlgebra R N := + lift ((ι R N) ∘ₗ f) + +@[simp] +lemma map_apply_ι (f : M →ₗ[R] N) (x : M) : map f (ι R M x) = ι R N (f x) := + lift_ι_apply _ x + +@[simp] +lemma map_id : map (LinearMap.id : M →ₗ[R] M) = AlgHom.id R (SymmetricAlgebra R M) := + algHom_ext (LinearMap.ext fun x => by simp) + +lemma map_comp_map (f : N →ₗ[R] P) (g : M →ₗ[R] N) : + (map f).comp (map g) = map (f ∘ₗ g) := + algHom_ext (LinearMap.ext fun x => by simp) + +/-- The algebra equivalence between symmetric algebras induced by a linear equivalence of + the underlying modules. -/ +def congr (e : M ≃ₗ[R] N) : SymmetricAlgebra R M ≃ₐ[R] SymmetricAlgebra R N := + AlgEquiv.ofAlgHom (map e.toLinearMap) (map e.symm.toLinearMap) + (by rw [map_comp_map]; simp) + (by rw [map_comp_map]; simp) + +@[simp] +lemma congr_apply_ι (e : M ≃ₗ[R] N) (x : M) : congr e (ι R M x) = ι R N (e x) := + map_apply_ι _ x + +/-! + +## B. Generation by the degree-one elements + +-/ + +/-- The symmetric algebra is generated, as an `R`-algebra, by the degree-one elements. -/ +@[simp] +lemma adjoin_range_ι : + Algebra.adjoin R (Set.range (ι R M)) = (⊤ : Subalgebra R (SymmetricAlgebra R M)) := by + have h : ∀ x : SymmetricAlgebra R M, x ∈ Algebra.adjoin R (Set.range (ι R M)) := by + intro x + induction x using SymmetricAlgebra.induction with + | algebraMap r => exact Subalgebra.algebraMap_mem _ r + | ι x => exact Algebra.subset_adjoin ⟨x, rfl⟩ + | mul a b ha hb => exact mul_mem ha hb + | add a b ha hb => exact add_mem ha hb + exact top_le_iff.mp fun x _ => h x + +/-! + +## C. The symmetric algebra of a direct sum + +The symmetric algebra of `M × N` is the tensor product of the symmetric algebras of the +summands. Unlike the exterior-algebra analogue this is the *ordinary* tensor product: the +generators of the two factors commute, as bosonic generators must. + +-/ + +open TensorProduct + +/-- The forward half of `prodEquiv`: a generator `(m, n)` is sent to + `ι m ⊗ 1 + 1 ⊗ ι n`. -/ +noncomputable def prodToTensor : + SymmetricAlgebra R (M × N) →ₐ[R] SymmetricAlgebra R M ⊗[R] SymmetricAlgebra R N := + lift (LinearMap.coprod + ((Algebra.TensorProduct.includeLeft.toLinearMap : SymmetricAlgebra R M →ₗ[R] _) ∘ₗ ι R M) + ((Algebra.TensorProduct.includeRight.toLinearMap : SymmetricAlgebra R N →ₗ[R] _) ∘ₗ ι R N)) + +@[simp] +lemma prodToTensor_ι (x : M × N) : + prodToTensor (ι R (M × N) x) + = ι R M x.1 ⊗ₜ[R] 1 + (1 : SymmetricAlgebra R M) ⊗ₜ[R] ι R N x.2 := + lift_ι_apply _ x + +/-- The backward half of `prodEquiv`: the two inclusions of the factors, multiplied + together. -/ +noncomputable def tensorToProd : + SymmetricAlgebra R M ⊗[R] SymmetricAlgebra R N →ₐ[R] SymmetricAlgebra R (M × N) := + Algebra.TensorProduct.lift (map (LinearMap.inl R M N)) (map (LinearMap.inr R M N)) + fun _ _ => Commute.all _ _ + +@[simp] +lemma tensorToProd_tmul (a : SymmetricAlgebra R M) (b : SymmetricAlgebra R N) : + tensorToProd (a ⊗ₜ[R] b) = map (LinearMap.inl R M N) a * map (LinearMap.inr R M N) b := + Algebra.TensorProduct.lift_tmul _ _ _ _ _ + +/-- **The symmetric algebra of a direct sum is the tensor product of the symmetric + algebras.** Two bosonic fields taken together are one field valued in the direct sum of + their target spaces; their generators commute, so the ordinary tensor product suffices — + no grading is needed, in contrast to the exterior-algebra analogue. -/ +noncomputable def prodEquiv : + SymmetricAlgebra R (M × N) ≃ₐ[R] SymmetricAlgebra R M ⊗[R] SymmetricAlgebra R N := + AlgEquiv.ofAlgHom prodToTensor tensorToProd + (Algebra.TensorProduct.ext + (algHom_ext (LinearMap.ext fun m => by + simp [Algebra.TensorProduct.includeLeft_apply])) + (algHom_ext (LinearMap.ext fun n => by + simp [Algebra.TensorProduct.includeRight_apply]))) + (algHom_ext (LinearMap.ext fun x => by + have hx : ((x.1, (0 : N)) : M × N) + ((0 : M), x.2) = x := by + refine Prod.ext ?_ ?_ <;> simp + calc (tensorToProd.comp prodToTensor) (ι R (M × N) x) + = tensorToProd (ι R M x.1 ⊗ₜ[R] 1 + (1 : SymmetricAlgebra R M) ⊗ₜ[R] ι R N x.2) := by + rw [AlgHom.comp_apply, prodToTensor_ι] + _ = ι R (M × N) (x.1, 0) + ι R (M × N) (0, x.2) := by + rw [map_add, tensorToProd_tmul, tensorToProd_tmul, map_one, map_one, mul_one, + one_mul, map_apply_ι, map_apply_ι] + rfl + _ = ι R (M × N) x := by rw [← map_add, hx] + _ = (AlgHom.id R (SymmetricAlgebra R (M × N))) (ι R (M × N) x) := rfl)) + +@[simp] +lemma prodEquiv_ι (x : M × N) : + prodEquiv (ι R (M × N) x) + = ι R M x.1 ⊗ₜ[R] 1 + (1 : SymmetricAlgebra R M) ⊗ₜ[R] ι R N x.2 := + prodToTensor_ι x + +/-! + +## D. The derivation extending a linear endomorphism + +A linear endomorphism `d` of `M` extends uniquely to a derivation of the symmetric algebra: +the map obeying the Leibniz rule whose value on a generator `ι x` is `ι (d x)`. It is built +by lifting the generator map `ι x ↦ (ι x, ι (d x))` to an algebra homomorphism into the +trivial square-zero extension and taking the second component. + +-/ + +section Derivation + +variable (d : M →ₗ[R] M) + +/-- The lift of the derivation extending `d` to the trivial square-zero extension of the + symmetric algebra: the algebra homomorphism `x ↦ (x, derivationOfLinear d x)`. -/ +noncomputable def derivationHom : + SymmetricAlgebra R M →ₐ[R] + TrivSqZeroExt (SymmetricAlgebra R M) (SymmetricAlgebra R M) := + lift + { toFun := fun x => (ι R M x, ι R M (d x)) + map_add' := fun x y => by simp only [map_add]; rfl + map_smul' := fun c x => by simp only [map_smul, RingHom.id_apply]; rfl } + +@[simp] +lemma derivationHom_ι (x : M) : + derivationHom d (ι R M x) = (ι R M x, ι R M (d x)) := + lift_ι_apply _ x + +/-- The first component of the square-zero lift is the identity. -/ +@[simp] +lemma derivationHom_fst (x : SymmetricAlgebra R M) : (derivationHom d x).fst = x := by + have h : (TrivSqZeroExt.fstHom R (SymmetricAlgebra R M) (SymmetricAlgebra R M)).comp + (derivationHom d) = AlgHom.id R (SymmetricAlgebra R M) := + algHom_ext (LinearMap.ext fun x => by simp) + exact DFunLike.congr_fun h x + +/-- **The derivation of the symmetric algebra extending a linear endomorphism** `d` of `M`: + the map obeying the Leibniz rule whose value on a generator `ι x` is `ι (d x)`. -/ +noncomputable def derivationOfLinear : SymmetricAlgebra R M →ₗ[R] SymmetricAlgebra R M where + toFun x := (derivationHom d x).snd + map_add' x y := congrArg TrivSqZeroExt.snd (map_add (derivationHom d) x y) + map_smul' c x := congrArg TrivSqZeroExt.snd (map_smul (derivationHom d) c x) + +@[simp] +lemma derivationOfLinear_ι (x : M) : + derivationOfLinear d (ι R M x) = ι R M (d x) := by + rw [show derivationOfLinear d (ι R M x) = (derivationHom d (ι R M x)).snd from rfl, + derivationHom_ι] + rfl + +@[simp] +lemma derivationOfLinear_one : derivationOfLinear d (1 : SymmetricAlgebra R M) = 0 := + congrArg TrivSqZeroExt.snd (map_one (derivationHom d)) + +@[simp] +lemma derivationOfLinear_algebraMap (r : R) : + derivationOfLinear d (algebraMap R (SymmetricAlgebra R M) r) = 0 := by + rw [Algebra.algebraMap_eq_smul_one, map_smul, derivationOfLinear_one, smul_zero] + +/-- The Leibniz rule for the derivation extending `d`. -/ +lemma derivationOfLinear_mul (x y : SymmetricAlgebra R M) : + derivationOfLinear d (x * y) + = derivationOfLinear d x * y + x * derivationOfLinear d y := by + have h : derivationOfLinear d (x * y) = + (derivationHom d x).fst * derivationOfLinear d y + + derivationOfLinear d x * (derivationHom d y).fst := + congrArg TrivSqZeroExt.snd (map_mul (derivationHom d) x y) + rw [derivationHom_fst, derivationHom_fst] at h + exact h.trans (add_comm _ _) + +/-- Derivations extending commuting endomorphisms commute. -/ +lemma derivationOfLinear_comm_apply {d₁ d₂ : M →ₗ[R] M} (h : d₁ ∘ₗ d₂ = d₂ ∘ₗ d₁) + (x : SymmetricAlgebra R M) : + derivationOfLinear d₁ (derivationOfLinear d₂ x) + = derivationOfLinear d₂ (derivationOfLinear d₁ x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => simp + | ι v => + simp only [derivationOfLinear_ι] + exact congrArg (ι R M) (DFunLike.congr_fun h v) + | mul x y hx hy => + simp only [derivationOfLinear_mul, map_add, hx, hy] + exact add_add_add_comm _ _ _ _ + | add x y hx hy => simp only [map_add, hx, hy] + +end Derivation + +end SymmetricAlgebra diff --git a/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean b/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean index af133c8e3..03983b715 100644 --- a/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean +++ b/Physlib/Particles/BeyondTheStandardModel/TwoHDM/Basic.lean @@ -59,21 +59,21 @@ lemma ext_of_fst_snd {H1 H2 : TwoHiggsDoublet} noncomputable instance : SMul StandardModel.GaugeGroupI TwoHiggsDoublet where smul g H := - { Φ1 := g • H.Φ1 - Φ2 := g • H.Φ2 } + { Φ1 := StandardModel.HiggsVec.repGaugeGroupI g H.Φ1 + Φ2 := StandardModel.HiggsVec.repGaugeGroupI g H.Φ2 } @[simp] lemma gaugeGroupI_smul_fst (g : StandardModel.GaugeGroupI) (H : TwoHiggsDoublet) : - (g • H).Φ1 = g • H.Φ1 := rfl + (g • H).Φ1 = StandardModel.HiggsVec.repGaugeGroupI g H.Φ1 := rfl @[simp] lemma gaugeGroupI_smul_snd (g : StandardModel.GaugeGroupI) (H : TwoHiggsDoublet) : - (g • H).Φ2 = g • H.Φ2 := rfl + (g • H).Φ2 = StandardModel.HiggsVec.repGaugeGroupI g H.Φ2 := rfl noncomputable instance : MulAction StandardModel.GaugeGroupI TwoHiggsDoublet where one_smul H := by ext <;> simp mul_smul g1 g2 H := by - ext <;> simp [mul_smul] + ext <;> simp [Module.End.mul_apply] end TwoHiggsDoublet diff --git a/Physlib/Particles/BeyondTheStandardModel/TwoHDM/GramMatrix.lean b/Physlib/Particles/BeyondTheStandardModel/TwoHDM/GramMatrix.lean index e6e319dba..e065eb1f6 100644 --- a/Physlib/Particles/BeyondTheStandardModel/TwoHDM/GramMatrix.lean +++ b/Physlib/Particles/BeyondTheStandardModel/TwoHDM/GramMatrix.lean @@ -89,17 +89,17 @@ lemma gramMatrix_tr_nonneg (H : TwoHiggsDoublet) : lemma gaugeGroupI_exists_fst_eq {H : TwoHiggsDoublet} (h1 : H.Φ1 ≠ 0) : ∃ g : StandardModel.GaugeGroupI, - g • H.Φ1 = (!₂[‖H.Φ1‖, 0] : HiggsVec) ∧ - (g • H.Φ2) 0 = ⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖ ∧ - ‖(g • H.Φ2) 1‖ = Real.sqrt (H.gramMatrix.det.re) / ‖H.Φ1‖ := by + HiggsVec.repGaugeGroupI g H.Φ1 = (!₂[‖H.Φ1‖, 0] : HiggsVec) ∧ + (HiggsVec.repGaugeGroupI g H.Φ2) 0 = ⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖ ∧ + ‖(HiggsVec.repGaugeGroupI g H.Φ2) 1‖ = Real.sqrt (H.gramMatrix.det.re) / ‖H.Φ1‖ := by rw [gramMatrix_det_eq_real] - obtain ⟨g, h⟩ := (HiggsVec.mem_orbit_gaugeGroupI_iff (H.Φ1) (!₂[‖H.Φ1‖, 0] : HiggsVec)).mpr - (by simp [@PiLp.norm_eq_of_L2]) + obtain ⟨g, h⟩ := (HiggsVec.exists_repGaugeGroupI_eq_iff_norm_eq (H.Φ1) + (!₂[‖H.Φ1‖, 0] : HiggsVec)).mpr (by simp [@PiLp.norm_eq_of_L2]) use g - simp at h simp [h] - have h_fst : (g • H.Φ2).ofLp 0 = ⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖ := by - have h2 : ⟪H.Φ1, H.Φ2⟫_ℂ = ⟪g • H.Φ1, g • H.Φ2⟫_ℂ := by + have h_fst : (HiggsVec.repGaugeGroupI g H.Φ2).ofLp 0 = ⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖ := by + have h2 : ⟪H.Φ1, H.Φ2⟫_ℂ = ⟪HiggsVec.repGaugeGroupI g H.Φ1, + HiggsVec.repGaugeGroupI g H.Φ2⟫_ℂ := by simp rw [h] at h2 conv_rhs at h2 => @@ -109,14 +109,16 @@ lemma gaugeGroupI_exists_fst_eq {H : TwoHiggsDoublet} (h1 : H.Φ1 ≠ 0) : simp_all field_simp apply And.intro h_fst - have hx : ‖g • H.Φ2‖ ^ 2 = ‖H.Φ2‖ ^ 2 := by + have hx : ‖HiggsVec.repGaugeGroupI g H.Φ2‖ ^ 2 = ‖H.Φ2‖ ^ 2 := by simp rw [PiLp.norm_sq_eq_of_L2] at hx simp at hx - have hx0 : ‖(g • H.Φ2).ofLp 1‖ ^ 2 = ‖H.Φ2‖ ^ 2 - ‖(g • H.Φ2).ofLp 0‖ ^ 2 := by + have hx0 : ‖(HiggsVec.repGaugeGroupI g H.Φ2).ofLp 1‖ ^ 2 = + ‖H.Φ2‖ ^ 2 - ‖(HiggsVec.repGaugeGroupI g H.Φ2).ofLp 0‖ ^ 2 := by rw [← hx] simp - have h0 : ‖(g • H.Φ2) 1‖ ^ 2 = (‖H.Φ1‖ ^ 2 * ‖H.Φ2‖ ^ 2 - ‖⟪H.Φ1, H.Φ2⟫_ℂ‖ ^ 2) / ‖H.Φ1‖ ^ 2 := by + have h0 : ‖(HiggsVec.repGaugeGroupI g H.Φ2) 1‖ ^ 2 = + (‖H.Φ1‖ ^ 2 * ‖H.Φ2‖ ^ 2 - ‖⟪H.Φ1, H.Φ2⟫_ℂ‖ ^ 2) / ‖H.Φ1‖ ^ 2 := by field_simp rw [hx0, h_fst] simp only [Fin.isValue, Complex.norm_div, Complex.norm_real, norm_norm] @@ -133,18 +135,19 @@ lemma gaugeGroupI_exists_fst_eq {H : TwoHiggsDoublet} (h1 : H.Φ1 ≠ 0) : ring_nf · exact norm_ne_zero_iff.mpr h1 · simpa using h1 - · exact norm_nonneg ((g • H.Φ2).ofLp 1) + · exact norm_nonneg ((HiggsVec.repGaugeGroupI g H.Φ2).ofLp 1) lemma gaugeGroupI_exists_fst_eq_snd_eq {H : TwoHiggsDoublet} (h1 : H.Φ1 ≠ 0) : ∃ g : StandardModel.GaugeGroupI, - g • H.Φ1 = (!₂[‖H.Φ1‖, 0] : HiggsVec) ∧ - g • H.Φ2 = (!₂[⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖, √(H.gramMatrix.det.re) / ‖H.Φ1‖] : HiggsVec) := by + HiggsVec.repGaugeGroupI g H.Φ1 = (!₂[‖H.Φ1‖, 0] : HiggsVec) ∧ + HiggsVec.repGaugeGroupI g H.Φ2 = + (!₂[⟪H.Φ1, H.Φ2⟫_ℂ / ‖H.Φ1‖, √(H.gramMatrix.det.re) / ‖H.Φ1‖] : HiggsVec) := by obtain ⟨g, h_fst, h_snd_0, h_snd_1⟩ := gaugeGroupI_exists_fst_eq h1 - obtain ⟨k, h1, h2, h3⟩ := HiggsVec.gaugeGroupI_smul_phase_snd (g • H.Φ2) + obtain ⟨k, h1, h2, h3⟩ := HiggsVec.repGaugeGroupI_phase_snd (HiggsVec.repGaugeGroupI g H.Φ2) use k * g apply And.intro - · rw [mul_smul, h_fst, h3] - · rw [mul_smul] + · rw [HiggsVec.repGaugeGroupI_mul_apply, h_fst, h3] + · rw [HiggsVec.repGaugeGroupI_mul_apply] ext i fin_cases i · simp @@ -162,10 +165,10 @@ lemma mem_orbit_gaugeGroupI_iff_gramMatrix (H1 H2 : TwoHiggsDoublet) : simp [← hg] by_cases Φ1_zero : H1.Φ1 = 0 · intro h - obtain ⟨g1, hg1⟩ := (HiggsVec.mem_orbit_gaugeGroupI_iff (H1.Φ2) (!₂[‖H1.Φ2‖, 0] : HiggsVec)).mpr - (by simp [@PiLp.norm_eq_of_L2]) - obtain ⟨g2, hg2⟩ := (HiggsVec.mem_orbit_gaugeGroupI_iff (H2.Φ2) (!₂[‖H2.Φ2‖, 0] : HiggsVec)).mpr - (by simp [@PiLp.norm_eq_of_L2]) + obtain ⟨g1, hg1⟩ := (HiggsVec.exists_repGaugeGroupI_eq_iff_norm_eq (H1.Φ2) + (!₂[‖H1.Φ2‖, 0] : HiggsVec)).mpr (by simp [@PiLp.norm_eq_of_L2]) + obtain ⟨g2, hg2⟩ := (HiggsVec.exists_repGaugeGroupI_eq_iff_norm_eq (H2.Φ2) + (!₂[‖H2.Φ2‖, 0] : HiggsVec)).mpr (by simp [@PiLp.norm_eq_of_L2]) use g1⁻¹ * g2 simp only ext:1 @@ -175,9 +178,8 @@ lemma mem_orbit_gaugeGroupI_iff_gramMatrix (H1 H2 : TwoHiggsDoublet) : rw [← eq_fst_norm_of_eq_gramMatrix h] simp [Φ1_zero] at hnorm simp [hnorm] - · simp [mul_smul] - refine inv_smul_eq_iff.mpr ?_ - simp at hg1 hg2 + · simp + refine (HiggsVec.repGaugeGroupI_inv_apply_eq_iff _ _ _).mpr ?_ simp [hg1, hg2] exact eq_snd_norm_of_eq_gramMatrix h.symm · intro h @@ -192,12 +194,12 @@ lemma mem_orbit_gaugeGroupI_iff_gramMatrix (H1 H2 : TwoHiggsDoublet) : use g1⁻¹ * g2 simp only ext:1 - · simp [mul_smul] - refine inv_smul_eq_iff.mpr ?_ + · simp + refine (HiggsVec.repGaugeGroupI_inv_apply_eq_iff _ _ _).mpr ?_ simp [H1_Φ1, H2_Φ1] apply eq_fst_norm_of_eq_gramMatrix h.symm - · simp [mul_smul] - refine inv_smul_eq_iff.mpr ?_ + · simp + refine (HiggsVec.repGaugeGroupI_inv_apply_eq_iff _ _ _).mpr ?_ simp [H1_Φ2, H2_Φ2] apply And.intro · congr 1 diff --git a/Physlib/Particles/LagrangianTheory/Basic.lean b/Physlib/Particles/LagrangianTheory/Basic.lean new file mode 100644 index 000000000..6a2b916d1 --- /dev/null +++ b/Physlib/Particles/LagrangianTheory/Basic.lean @@ -0,0 +1,1159 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith, Jinzheng Li, Nathaneal Sajan +-/ +module + +public import Physlib.Relativity.Fermions.Weyl.Metric +public import Physlib.Relativity.DerivAlgebra +public import Physlib.Particles.StandardModel.HiggsBoson.Basic +public import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Mathematics.ConjModule +public import Mathlib.RingTheory.GradedAlgebra.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +public import Mathlib.RingTheory.TensorProduct.Maps +public import Mathlib.LinearAlgebra.CliffordAlgebra.Contraction +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basis +public import Mathlib.Algebra.MvPolynomial.PDeriv +public import Mathlib.Data.Finsupp.Multiset +public import Mathlib.LinearAlgebra.TensorAlgebra.Basis +public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic +public import Physlib.Relativity.Tensors.RealTensor.CoVector.Representation +public import Physlib.Relativity.SL2C.Basic +/-! + +# The Standard Model EFT Lagrangian without derivatives + +## i. Overview + +-/ + +@[expose] public section + +/-! + +## The basic type for a lagrangian theory + +-/ +open Matrix MatrixGroups Module TensorProduct + +structure LagrangianTheory (G : Type) [Group G] where + -- The fermions + FermionIrreps : Type + [fermionIrreps_fintype : Fintype FermionIrreps] + [fermionIrreps_decEq : DecidableEq FermionIrreps] + FermionComponents : FermionIrreps → Type + [fermionComponents_fintype : ∀ φ, Fintype (FermionComponents φ)] + [fermionComponents_decEq : ∀ φ, DecidableEq (FermionComponents φ)] + fermionModule : ∀ (_ : FermionIrreps), Type + [fermionModule_addCommGroup : ∀ φ, AddCommGroup (fermionModule φ)] + [fermionModule_module : ∀ φ, Module ℂ (fermionModule φ)] + fermionBasis : ∀ φ, Basis (FermionComponents φ) ℂ (fermionModule φ) + fermionRepLorentzGroup : ∀ φ, Representation ℂ SL(2,ℂ) (fermionModule φ) + fermionRepGaugeGroup : ∀ φ, Representation ℂ G (fermionModule φ) + -- The complex scalars + ComplexScalarIrreps : Type + [complexScalarIrreps_fintype : Fintype ComplexScalarIrreps] + [complexScalarIrreps_decEq : DecidableEq ComplexScalarIrreps] + ComplexScalarComponents : ComplexScalarIrreps → Type + [complexScalarComponents_fintype : ∀ φ, Fintype (ComplexScalarComponents φ)] + [complexScalarComponents_decEq : ∀ φ, DecidableEq (ComplexScalarComponents φ)] + complexScalarModule : ∀ (_ : ComplexScalarIrreps), Type + [complexScalarModule_addCommGroup : ∀ φ, AddCommGroup (complexScalarModule φ)] + [complexScalarModule_module : ∀ φ, Module ℂ (complexScalarModule φ)] + complexScalarBasis : ∀ φ, Basis (ComplexScalarComponents φ) ℂ (complexScalarModule φ) + complexScalarRepLorentzGroup : ∀ φ, Representation ℂ SL(2,ℂ) (complexScalarModule φ) + complexScalarRepGaugeGroup : ∀ φ, Representation ℂ G (complexScalarModule φ) + -- The real bosonic fields (e.g. the gauge bosons of the theory.) + RealBosonIrreps : Type + [realBosonIrreps_fintype : Fintype RealBosonIrreps] + [realBosonIrreps_decEq : DecidableEq RealBosonIrreps] + RealBosonComponents : RealBosonIrreps → Type + [realBosonComponents_fintype : ∀ φ, Fintype (RealBosonComponents φ)] + [realBosonComponents_decEq : ∀ φ, DecidableEq (RealBosonComponents φ)] + realBosonModule : ∀ (_ : RealBosonIrreps), Type + [realBosonModule_addCommGroup : ∀ φ, AddCommGroup (realBosonModule φ)] + [realBosonModule_module : ∀ φ, Module ℝ (realBosonModule φ)] + realBosonBasis : ∀ φ, Basis (RealBosonComponents φ) ℝ (realBosonModule φ) + realBosonRepLorentzGroup : ∀ φ, Representation ℝ SL(2,ℂ) (realBosonModule φ) + realBosonRepGaugeGroup : ∀ φ, Representation ℝ G (realBosonModule φ) + +namespace LagrangianTheory + + +attribute [instance] fermionIrreps_fintype fermionIrreps_decEq + fermionComponents_fintype fermionComponents_decEq + fermionModule_addCommGroup fermionModule_module + complexScalarIrreps_fintype complexScalarIrreps_decEq + complexScalarComponents_fintype complexScalarComponents_decEq + complexScalarModule_addCommGroup complexScalarModule_module + realBosonIrreps_fintype realBosonIrreps_decEq + realBosonComponents_fintype realBosonComponents_decEq + realBosonModule_addCommGroup realBosonModule_module + +variable {G : Type} [Group G] + +/-! + +## A. Definitions related to fermions + +-/ + +inductive FermionicGenerator (L : LagrangianTheory G) + | of (φ : L.FermionIrreps) (α : L.FermionComponents φ) : L.FermionicGenerator + | bar (φ : L.FermionIrreps) (α : L.FermionComponents φ) : L.FermionicGenerator +deriving DecidableEq, Fintype + +def FermionicGenerator.conjugate {L : LagrangianTheory G} : + L.FermionicGenerator → L.FermionicGenerator + | .of φ α => .bar φ α + | .bar φ α => .of φ α + +@[simp] +lemma FermionicGenerator.conjugate_conjugate {L : LagrangianTheory G} (g : L.FermionicGenerator) : + g.conjugate.conjugate = g := by + cases g <;> rfl + +def fermionicGeneratorEquiv {L : LagrangianTheory G} : L.FermionicGenerator ≃ + (Σ φ : L.FermionIrreps, L.FermionComponents φ) ⊕ (Σ φ : L.FermionIrreps, L.FermionComponents φ) where + toFun g := match g with + | .of φ α => Sum.inl ⟨φ, α⟩ + | .bar φ α => Sum.inr ⟨φ, α⟩ + invFun g := match g with + | Sum.inl ⟨φ, α⟩ => .of φ α + | Sum.inr ⟨φ, α⟩ => .bar φ α + left_inv g := by cases g <;> rfl + right_inv g := by cases g <;> rfl + +inductive FermionicJetGenerator (L : LagrangianTheory G) + | of (μ : Multiset (Fin 1 ⊕ Fin 3)) (φ : L.FermionIrreps) (α : L.FermionComponents φ) : + L.FermionicJetGenerator + | bar (μ : Multiset (Fin 1 ⊕ Fin 3)) (φ : L.FermionIrreps) (α : L.FermionComponents φ) : + L.FermionicJetGenerator + +def fermionicJetGeneratorEquiv {L : LagrangianTheory G} : L.FermionicJetGenerator ≃ + (Multiset (Fin 1 ⊕ Fin 3) × Σ φ : L.FermionIrreps, L.FermionComponents φ) ⊕ + (Multiset (Fin 1 ⊕ Fin 3) × Σ φ : L.FermionIrreps, L.FermionComponents φ) where + toFun g := match g with + | .of μ φ α => Sum.inl (μ, ⟨φ, α⟩) + | .bar μ φ α => Sum.inr (μ, ⟨φ, α⟩) + invFun g := match g with + | Sum.inl (μ, ⟨φ, α⟩) => .of μ φ α + | Sum.inr (μ, ⟨φ, α⟩) => .bar μ φ α + left_inv g := by cases g <;> rfl + right_inv g := by cases g <;> rfl + +/-! + +### A.1. The vector spaces of the fermionic fields. + +-/ + +/-- The target vector space of the fermionic fields. + If fermions are consider in terms of an associated-bundle, this vector space + would be the fiber of that bundle. + + This vector space includes all the fields appearing in the theory. -/ +abbrev FermionicTargetSpace (L : LagrangianTheory G) := Π (φ : L.FermionIrreps), L.fermionModule φ + +/-- The target vector space of the jet-bundle coordinates of fermions e.g. ∂_μ ψ. + This is the fiber of the jet bundle associated with the fermions: since partial + derivatives commute, the derivative slots form a symmetric algebra. + + This vector space includes all the fields in the theory + their derivative coordinates. -/ +abbrev FermionicJetSpace (L : LagrangianTheory G) := + SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] L.FermionicTargetSpace + +/-- The fermionic target space linearly embeds into the fermionic target space with derivatives. -/ +def FermionicTargetSpace.toFermionicJetSpace {L : LagrangianTheory G} : + L.FermionicTargetSpace →ₗ[ℂ] L.FermionicJetSpace := + TensorProduct.mk ℂ (SymmetricAlgebra ℂ Lorentz.CoℂModule) L.FermionicTargetSpace 1 + +/-- Since fermions are complex fields, we also need to consider the target space of their + complex conjugate. The vector space `FermionicTargetSpaceWithComplex` is defined + to contain both the target space of the fields, and their conjugates. + + This vector space includes all the fields appearing in the theory + their conjugates. -/ +abbrev FermionicTargetSpaceWithComplex (L : LagrangianTheory G) := L.FermionicTargetSpace × + ConjModule L.FermionicTargetSpace + +/-- Similar to `FermionicTargetSpaceWithComplex` except including derivatives. + + This vector space includes all the fields present in the theory + their conjugates + all + their jet-bundle derivative coordinates. -/ +abbrev FermionicJetSpaceWithComplex (L : LagrangianTheory G) := + (SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] L.FermionicTargetSpace) × + (SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] ConjModule L.FermionicTargetSpace) + +/-- The vector space dual to `FermionicTargetSpaceWithComplex` and spanned by the component + functions of all the fields + their conjugates in the theory. -/ +abbrev FermionicComponentSpace (L : LagrangianTheory G) := + Module.Dual ℂ L.FermionicTargetSpaceWithComplex + +/-- The vector space spanned by the component functions of all the fields + their + conjugates + all their jet-bundle derivative coordinates in the theory. + + This is the *graded* dual of `FermionicJetSpaceWithComplex`: the duals of the + finite-dimensional building blocks are dualized individually and reassembled. The full + `Module.Dual` of `FermionicJetSpaceWithComplex` is strictly larger (the latter is + infinite dimensional) and is not spanned by the component functions. -/ +abbrev FermionicJetComponentSpace (L : LagrangianTheory G) := + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ L.FermionicTargetSpace) × + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule L.FermionicTargetSpace)) + +/-! + +## A.2. The fermionic algebras + +-/ + +/-- The EFT algebra spanned by the fermions in the theory + their conjugate. -/ +abbrev FermionicEFTExclDeriv (L : LagrangianTheory G) := ExteriorAlgebra ℂ L.FermionicComponentSpace + +/-- The EFT algebra spanned by the fermions in the theory + their conjugate + all their + jet-bundle derivative coordinates, without taking account of total derivatives or + equations of motion relations. -/ +abbrev FermionicEFTJet (L : LagrangianTheory G) := + ExteriorAlgebra ℂ L.FermionicJetComponentSpace + +/-! + +## A.3. The basis of the fermionic vector spaces + +The main vector spaces are `FermionicComponentSpace` and `FermionicJetComponentSpace`. +On these spaces we want to define a basis indexed by `FermionicGenerator` and +`FermionicJetGenerator` respectively. + +-/ + +noncomputable def FermionicComponentSpace.basis {L : LagrangianTheory G} : + Basis L.FermionicGenerator ℂ L.FermionicComponentSpace := + ((Pi.basis (fun φ => L.fermionBasis φ)).prod + ((Pi.basis (fun φ => L.fermionBasis φ)).conj)).dualBasis.reindex fermionicGeneratorEquiv.symm + +noncomputable def FermionicJetComponentSpace.basis {L : LagrangianTheory G} : + Basis L.FermionicJetGenerator ℂ L.FermionicJetComponentSpace := + ((DerivAlgebraComplex.basis.tensorProduct + (Pi.basis fun φ => L.fermionBasis φ).dualBasis).prod + (DerivAlgebraComplex.basis.tensorProduct + ((Pi.basis fun φ => L.fermionBasis φ).conj.dualBasis))).reindex + fermionicJetGeneratorEquiv.symm + +/-! + +## A.4. The representation of the Lorentz group on fermionic vector spaces and algebras + +We now define the respresentation of the Lorentz group on the vector spaces +and algebras associated with Fermions. Note that since we are dealing with complex +fields we take the Lorentz group to be `SL(2,ℂ)`, rather than dealing with projective +representations of the Lorentz group. + +We are particularly interested in the representations acting on +- the vector spaces `FermionicComponentSpace` and `FermionicJetComponentSpace`, and +- the algebras `FermionicEFTExclDeriv` and `FermionicEFTJet`. + +To define the representations on vector spaces involving derivatives, +we first need to define the representations on the derivative algebras. + +-/ + + +variable {L : LagrangianTheory G} + +/-- The representation of the Lorentz group on the symmetric algebra of jet + coordinates, acting through `CoℂModule.SL2CRep` on each factor. -/ +noncomputable def jetAlgebraRepLorentzGroup : + Representation ℂ SL(2,ℂ) (SymmetricAlgebra ℂ Lorentz.CoℂModule) where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +def FermionicTargetSpace.repLorentzGroup : Representation ℂ SL(2,ℂ) L.FermionicTargetSpace where + toFun Λ := LinearMap.piMap fun φ => L.fermionRepLorentzGroup φ Λ + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' Λ1 Λ2 := by + ext x i y + simp + +noncomputable def FermionicTargetSpaceWithComplex.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.FermionicTargetSpaceWithComplex := + FermionicTargetSpace.repLorentzGroup.prod (FermionicTargetSpace.repLorentzGroup.conj) + +noncomputable def FermionicComponentSpace.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.FermionicComponentSpace := + FermionicTargetSpaceWithComplex.repLorentzGroup.dual + +noncomputable def FermionicJetComponentSpace.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.FermionicJetComponentSpace := + (DerivAlgebraComplex.repLorentzGroup.tprod FermionicTargetSpace.repLorentzGroup.dual).prod + (DerivAlgebraComplex.repLorentzGroup.tprod FermionicTargetSpace.repLorentzGroup.conj.dual) + +noncomputable def FermionicEFTExclDeriv.repLorentzGroup : Representation ℂ SL(2,ℂ) L.FermionicEFTExclDeriv where + toFun Λ := (ExteriorAlgebra.map (FermionicComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp only [map_one, End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' Λ1 Λ2 := by + simp only [map_mul, End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +/-- The representation of the Lorentz group on the algebra `FermionicEFTJet`. -/ +noncomputable def FermionicEFTJet.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.FermionicEFTJet where + toFun Λ := (ExteriorAlgebra.map (FermionicJetComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp only [map_one, End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' Λ1 Λ2 := by + simp only [map_mul, End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +/-! + +### A.5. The representation of the Gauge group on fermionic vector spaces and algebras + +-/ + +def FermionicTargetSpace.repGaugeGroup : Representation ℂ G L.FermionicTargetSpace where + toFun Λ := LinearMap.piMap fun φ => L.fermionRepGaugeGroup φ Λ + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' Λ1 Λ2 := by + ext x i y + simp + +noncomputable def FermionicTargetSpaceWithComplex.repGaugeGroup : + Representation ℂ G L.FermionicTargetSpaceWithComplex := + FermionicTargetSpace.repGaugeGroup.prod (FermionicTargetSpace.repGaugeGroup.conj) + +/-- The representation of the gauge group on the jet space of the fermionic fields. + The gauge group acts trivially on the derivative slots, so that the jet coordinates + `∂ ⋯ ∂ ψ` transform in the same representation of the gauge group as `ψ` itself. -/ +noncomputable def FermionicJetSpace.repGaugeGroup : + Representation ℂ G L.FermionicJetSpace := + (Representation.trivial ℂ G (SymmetricAlgebra ℂ Lorentz.CoℂModule)).tprod + FermionicTargetSpace.repGaugeGroup + +noncomputable def FermionicComponentSpace.repGaugeGroup : Representation ℂ G L.FermionicComponentSpace := + FermionicTargetSpaceWithComplex.repGaugeGroup.dual + +/-- The representation of the gauge group on the space of component functions of the + fermionic fields, their conjugates, and their jet-bundle derivative coordinates; + trivial on the derivative slots. -/ +noncomputable def FermionicJetComponentSpace.repGaugeGroup : + Representation ℂ G L.FermionicJetComponentSpace := + ((Representation.trivial ℂ G (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule))).tprod + FermionicTargetSpace.repGaugeGroup.dual).prod + ((Representation.trivial ℂ G (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule))).tprod + FermionicTargetSpace.repGaugeGroup.conj.dual) + +noncomputable def FermionicEFTExclDeriv.repGaugeGroup : Representation ℂ G L.FermionicEFTExclDeriv where + toFun Λ := (ExteriorAlgebra.map (FermionicComponentSpace.repGaugeGroup Λ)).toLinearMap + map_one' := by + simp only [map_one, End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' Λ1 Λ2 := by + simp only [map_mul, End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +noncomputable def FermionicEFTJet.repGaugeGroup : + Representation ℂ G L.FermionicEFTJet where + toFun g := (ExteriorAlgebra.map (FermionicJetComponentSpace.repGaugeGroup g)).toLinearMap + map_one' := by + simp only [map_one, End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' g1 g2 := by + simp only [map_mul, End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +/-! + +## B. Definitions related to the complex scalars + +-/ + +inductive ComplexScalarGenerator (L : LagrangianTheory G) + | of (φ : L.ComplexScalarIrreps) (α : L.ComplexScalarComponents φ) : L.ComplexScalarGenerator + | bar (φ : L.ComplexScalarIrreps) (α : L.ComplexScalarComponents φ) : L.ComplexScalarGenerator +deriving DecidableEq, Fintype + +def ComplexScalarGenerator.conjugate : L.ComplexScalarGenerator → L.ComplexScalarGenerator + | .of φ α => .bar φ α + | .bar φ α => .of φ α + +@[simp] +lemma ComplexScalarGenerator.conjugate_conjugate (g : L.ComplexScalarGenerator) : + g.conjugate.conjugate = g := by + cases g <;> rfl + +def complexScalarGeneratorEquiv : L.ComplexScalarGenerator ≃ + (Σ φ : L.ComplexScalarIrreps, L.ComplexScalarComponents φ) ⊕ + (Σ φ : L.ComplexScalarIrreps, L.ComplexScalarComponents φ) where + toFun g := match g with + | .of φ α => Sum.inl ⟨φ, α⟩ + | .bar φ α => Sum.inr ⟨φ, α⟩ + invFun g := match g with + | Sum.inl ⟨φ, α⟩ => .of φ α + | Sum.inr ⟨φ, α⟩ => .bar φ α + left_inv g := by cases g <;> rfl + right_inv g := by cases g <;> rfl + +inductive ComplexScalarJetGenerator (L : LagrangianTheory G) + | of (μ : Multiset (Fin 1 ⊕ Fin 3)) (φ : L.ComplexScalarIrreps) + (α : L.ComplexScalarComponents φ) : L.ComplexScalarJetGenerator + | bar (μ : Multiset (Fin 1 ⊕ Fin 3)) (φ : L.ComplexScalarIrreps) + (α : L.ComplexScalarComponents φ) : L.ComplexScalarJetGenerator + +def complexScalarJetGeneratorEquiv : L.ComplexScalarJetGenerator ≃ + (Multiset (Fin 1 ⊕ Fin 3) × Σ φ : L.ComplexScalarIrreps, L.ComplexScalarComponents φ) ⊕ + (Multiset (Fin 1 ⊕ Fin 3) × Σ φ : L.ComplexScalarIrreps, L.ComplexScalarComponents φ) where + toFun g := match g with + | .of μ φ α => Sum.inl (μ, ⟨φ, α⟩) + | .bar μ φ α => Sum.inr (μ, ⟨φ, α⟩) + invFun g := match g with + | Sum.inl (μ, ⟨φ, α⟩) => .of μ φ α + | Sum.inr (μ, ⟨φ, α⟩) => .bar μ φ α + left_inv g := by cases g <;> rfl + right_inv g := by cases g <;> rfl + +/-! + +### B.1. The vector spaces of the complex scalar fields. + +-/ + +/-- The target vector space of the complex scalar fields. + + This vector space includes all the complex scalar fields appearing in the theory. -/ +abbrev ComplexScalarTargetSpace (L : LagrangianTheory G) := + Π (φ : L.ComplexScalarIrreps), L.complexScalarModule φ + +/-- The target vector space of the jet-bundle coordinates of the complex scalar + fields e.g. ∂_μ ϕ. This is the fiber of the jet bundle associated with the scalars: + since partial derivatives commute, the derivative slots form a symmetric algebra. + + This vector space includes all the complex scalar fields in the theory + their + derivative coordinates. -/ +abbrev ComplexScalarJetSpace (L : LagrangianTheory G) := + SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] L.ComplexScalarTargetSpace + +/-- The complex scalar target space linearly embeds into the complex scalar target + space with derivatives. -/ +def ComplexScalarTargetSpace.toComplexScalarJetSpace {L : LagrangianTheory G} : + L.ComplexScalarTargetSpace →ₗ[ℂ] L.ComplexScalarJetSpace := + TensorProduct.mk ℂ (SymmetricAlgebra ℂ Lorentz.CoℂModule) L.ComplexScalarTargetSpace 1 + +/-- The target space of the complex scalar fields, including their conjugates. -/ +abbrev ComplexScalarTargetSpaceWithComplex (L : LagrangianTheory G) := + L.ComplexScalarTargetSpace × ConjModule L.ComplexScalarTargetSpace + +/-- Similar to `ComplexScalarTargetSpaceWithComplex` except including derivatives. + + This vector space includes all the complex scalar fields present in the theory + + their conjugates + all their jet-bundle derivative coordinates. -/ +abbrev ComplexScalarJetSpaceWithComplex (L : LagrangianTheory G) := + (SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] L.ComplexScalarTargetSpace) × + (SymmetricAlgebra ℂ Lorentz.CoℂModule ⊗[ℂ] ConjModule L.ComplexScalarTargetSpace) + +/-- The vector space dual to `ComplexScalarTargetSpaceWithComplex` and spanned by the + component functions of all the complex scalar fields + their conjugates in the + theory. -/ +abbrev ComplexScalarComponentSpace (L : LagrangianTheory G) := + Module.Dual ℂ L.ComplexScalarTargetSpaceWithComplex + +/-- The vector space spanned by the component functions of all the complex scalar + fields + their conjugates + all their jet-bundle derivative coordinates in the + theory. + + This is the *graded* dual of `ComplexScalarJetSpaceWithComplex`: the duals of the + finite-dimensional building blocks are dualized individually and reassembled. The + full `Module.Dual` of `ComplexScalarJetSpaceWithComplex` is strictly larger (the + latter is infinite dimensional) and is not spanned by the component functions. -/ +abbrev ComplexScalarJetComponentSpace (L : LagrangianTheory G) := + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ L.ComplexScalarTargetSpace) × + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule L.ComplexScalarTargetSpace)) + +/-! + +### B.2. The complex scalar algebras + +-/ + +/-- The EFT algebra spanned by the complex scalars in the theory + their conjugate. -/ +abbrev ComplexScalarEFTExclDeriv (L : LagrangianTheory G) := + SymmetricAlgebra ℂ L.ComplexScalarComponentSpace + +/-- The EFT algebra spanned by the complex scalars in the theory + their conjugate + + all their jet-bundle derivative coordinates, without taking account of total + derivatives or equations of motion relations. -/ +abbrev ComplexScalarEFTJet (L : LagrangianTheory G) := + SymmetricAlgebra ℂ L.ComplexScalarJetComponentSpace + +/-! + +### B.3. The basis of the complex scalar vector spaces + +The main vector spaces are `ComplexScalarComponentSpace` and +`ComplexScalarJetComponentSpace`. On these spaces we want to define a basis +indexed by `ComplexScalarGenerator` and `ComplexScalarJetGenerator` respectively. + +-/ + +noncomputable def ComplexScalarComponentSpace.basis : + Basis L.ComplexScalarGenerator ℂ L.ComplexScalarComponentSpace := + ((Pi.basis (fun φ => L.complexScalarBasis φ)).prod + ((Pi.basis (fun φ => L.complexScalarBasis φ)).conj)).dualBasis.reindex + complexScalarGeneratorEquiv.symm + +noncomputable def ComplexScalarJetComponentSpace.basis : + Basis L.ComplexScalarJetGenerator ℂ L.ComplexScalarJetComponentSpace := + ((DerivAlgebraComplex.basis.tensorProduct + (Pi.basis fun φ => L.complexScalarBasis φ).dualBasis).prod + (DerivAlgebraComplex.basis.tensorProduct + ((Pi.basis fun φ => L.complexScalarBasis φ).conj.dualBasis))).reindex + complexScalarJetGeneratorEquiv.symm + +/-! + +### B.4. The representation of the Lorentz group on complex scalar vector spaces and algebras + +-/ + +def ComplexScalarTargetSpace.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarTargetSpace where + toFun Λ := LinearMap.piMap fun φ => L.complexScalarRepLorentzGroup φ Λ + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' Λ1 Λ2 := by + ext x i y + simp + +noncomputable def ComplexScalarTargetSpaceWithComplex.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarTargetSpaceWithComplex := + ComplexScalarTargetSpace.repLorentzGroup.prod (ComplexScalarTargetSpace.repLorentzGroup.conj) + +noncomputable def ComplexScalarComponentSpace.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarComponentSpace := + ComplexScalarTargetSpaceWithComplex.repLorentzGroup.dual + +noncomputable def ComplexScalarJetComponentSpace.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarJetComponentSpace := + (DerivAlgebraComplex.repLorentzGroup.tprod ComplexScalarTargetSpace.repLorentzGroup.dual).prod + (DerivAlgebraComplex.repLorentzGroup.tprod ComplexScalarTargetSpace.repLorentzGroup.conj.dual) + +noncomputable def ComplexScalarEFTExclDeriv.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarEFTExclDeriv where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repLorentzGroup (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repLorentzGroup Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repLorentzGroup Λ2)) by + rw [h]; rfl + ext v + simp + +/-- The representation of the Lorentz group on the algebra `ComplexScalarEFTJet`. -/ +noncomputable def ComplexScalarEFTJet.repLorentzGroup : + Representation ℂ SL(2,ℂ) L.ComplexScalarEFTJet where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repLorentzGroup (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repLorentzGroup Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repLorentzGroup Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +/-! + +### B.5. The representation of the Gauge group on complex scalar vector spaces and algebras + +-/ + +def ComplexScalarTargetSpace.repGaugeGroup : + Representation ℂ G L.ComplexScalarTargetSpace where + toFun g := LinearMap.piMap fun φ => L.complexScalarRepGaugeGroup φ g + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' g1 g2 := by + ext x i y + simp + +noncomputable def ComplexScalarTargetSpaceWithComplex.repGaugeGroup : + Representation ℂ G L.ComplexScalarTargetSpaceWithComplex := + ComplexScalarTargetSpace.repGaugeGroup.prod (ComplexScalarTargetSpace.repGaugeGroup.conj) + +/-- The representation of the gauge group on the jet space of the complex scalar + fields. The gauge group acts trivially on the derivative slots, so that the jet + coordinates `∂ ⋯ ∂ ϕ` transform in the same representation of the gauge group as + `ϕ` itself. -/ +noncomputable def ComplexScalarJetSpace.repGaugeGroup : + Representation ℂ G L.ComplexScalarJetSpace := + (Representation.trivial ℂ G (SymmetricAlgebra ℂ Lorentz.CoℂModule)).tprod + ComplexScalarTargetSpace.repGaugeGroup + +noncomputable def ComplexScalarComponentSpace.repGaugeGroup : + Representation ℂ G L.ComplexScalarComponentSpace := + ComplexScalarTargetSpaceWithComplex.repGaugeGroup.dual + +/-- The representation of the gauge group on the space of component functions of the + complex scalar fields, their conjugates, and their jet-bundle derivative + coordinates; trivial on the derivative slots. -/ +noncomputable def ComplexScalarJetComponentSpace.repGaugeGroup : + Representation ℂ G L.ComplexScalarJetComponentSpace := + ((Representation.trivial ℂ G (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule))).tprod + ComplexScalarTargetSpace.repGaugeGroup.dual).prod + ((Representation.trivial ℂ G (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule))).tprod + ComplexScalarTargetSpace.repGaugeGroup.conj.dual) + +noncomputable def ComplexScalarEFTExclDeriv.repGaugeGroup : + Representation ℂ G L.ComplexScalarEFTExclDeriv where + toFun g := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repGaugeGroup g)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' g1 g2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repGaugeGroup (g1 * g2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repGaugeGroup g1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarComponentSpace.repGaugeGroup g2)) by + rw [h]; rfl + ext v + simp + +noncomputable def ComplexScalarEFTJet.repGaugeGroup : + Representation ℂ G L.ComplexScalarEFTJet where + toFun g := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repGaugeGroup g)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' g1 g2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repGaugeGroup (g1 * g2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repGaugeGroup g1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ ComplexScalarJetComponentSpace.repGaugeGroup g2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +/-! + +## C. Definitions related to real bosons + +The real bosonic fields (for example the field strengths of the gauge bosons) are +genuinely real, so unlike the fermions and complex scalars there is no conjugate +field, and every vector space and algebra below is taken over `ℝ`. + +-/ + +inductive RealBosonGenerator (L : LagrangianTheory G) + | of (φ : L.RealBosonIrreps) (α : L.RealBosonComponents φ) : L.RealBosonGenerator +deriving DecidableEq, Fintype + +def realBosonGeneratorEquiv : + L.RealBosonGenerator ≃ Σ φ : L.RealBosonIrreps, L.RealBosonComponents φ where + toFun g := match g with + | .of φ α => ⟨φ, α⟩ + invFun g := match g with + | ⟨φ, α⟩ => .of φ α + left_inv g := by cases g; rfl + right_inv g := by cases g; rfl + +inductive RealBosonJetGenerator (L : LagrangianTheory G) + | of (μ : Multiset (Fin 1 ⊕ Fin 3)) (φ : L.RealBosonIrreps) (α : L.RealBosonComponents φ) : + L.RealBosonJetGenerator + +def realBosonJetGeneratorEquiv : L.RealBosonJetGenerator ≃ + Multiset (Fin 1 ⊕ Fin 3) × Σ φ : L.RealBosonIrreps, L.RealBosonComponents φ where + toFun g := match g with + | .of μ φ α => (μ, ⟨φ, α⟩) + invFun g := match g with + | (μ, ⟨φ, α⟩) => .of μ φ α + left_inv g := by cases g; rfl + right_inv g := by cases g; rfl + +/-! + +### C.1. The vector spaces of the real bosonic fields. + +-/ + +/-- The target vector space of the real bosonic fields. + + This vector space includes all the real bosonic fields appearing in the theory. -/ +abbrev RealBosonTargetSpace (L : LagrangianTheory G) := + Π (φ : L.RealBosonIrreps), L.realBosonModule φ + +/-- The target vector space of the jet-bundle coordinates of the real bosonic fields + e.g. ∂_μ B. Since partial derivatives commute, the derivative slots form a + symmetric algebra. + + This vector space includes all the real bosonic fields in the theory + their + derivative coordinates. -/ +abbrev RealBosonJetSpace (L : LagrangianTheory G) := + SymmetricAlgebra ℝ Lorentz.CoVector ⊗[ℝ] L.RealBosonTargetSpace + +/-- The real bosonic target space linearly embeds into the real bosonic target space + with derivatives. -/ +def RealBosonTargetSpace.toRealBosonJetSpace {L : LagrangianTheory G} : + L.RealBosonTargetSpace →ₗ[ℝ] L.RealBosonJetSpace := + TensorProduct.mk ℝ (SymmetricAlgebra ℝ Lorentz.CoVector) L.RealBosonTargetSpace 1 + +/-- The vector space dual to `RealBosonTargetSpace` and spanned by the component + functions of all the real bosonic fields in the theory. There is no conjugate + factor, since the fields are real. -/ +abbrev RealBosonComponentSpace (L : LagrangianTheory G) := + Module.Dual ℝ L.RealBosonTargetSpace + +/-- The vector space spanned by the component functions of all the real bosonic + fields + all their jet-bundle derivative coordinates in the theory. + + This is the *graded* dual of `RealBosonJetSpace`: the duals of the + finite-dimensional building blocks are dualized individually and reassembled. -/ +abbrev RealBosonJetComponentSpace (L : LagrangianTheory G) := + SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector) ⊗[ℝ] Module.Dual ℝ L.RealBosonTargetSpace + +/-! + +### C.2. The real bosonic algebras + +-/ + +/-- The EFT algebra spanned by the real bosonic fields in the theory. -/ +abbrev RealBosonEFTExclDeriv (L : LagrangianTheory G) := + SymmetricAlgebra ℝ L.RealBosonComponentSpace + +/-- The EFT algebra spanned by the real bosonic fields in the theory + all their + jet-bundle derivative coordinates, without taking account of total derivatives or + equations of motion relations. -/ +abbrev RealBosonEFTJet (L : LagrangianTheory G) := + SymmetricAlgebra ℝ L.RealBosonJetComponentSpace + + +/-- The real bosonic EFT algebra with complex coefficients: the real bosonic EFT + algebra with scalars extended from `ℝ` to `ℂ`, so that it can be combined with the + complex scalar and fermionic algebras in the full EFT Lagrangian. -/ +abbrev RealBosonEFTExclDerivComplex (L : LagrangianTheory G) := ℂ ⊗[ℝ] L.RealBosonEFTExclDeriv + +/-- The real bosonic EFT algebra including jet-bundle derivative coordinates, with complex + coefficients: `RealBosonEFTJet` with scalars extended from `ℝ` to `ℂ`, so + that it can be combined with the complex scalar and fermionic algebras in the full + EFT Lagrangian. -/ +abbrev RealBosonEFTJetComplex (L : LagrangianTheory G) := ℂ ⊗[ℝ] L.RealBosonEFTJet + + +/-! + +### C.3. The basis of the real bosonic vector spaces + +-/ + +noncomputable def RealBosonComponentSpace.basis : + Basis L.RealBosonGenerator ℝ L.RealBosonComponentSpace := + (Pi.basis (fun φ => L.realBosonBasis φ)).dualBasis.reindex realBosonGeneratorEquiv.symm + +/-- The basis of the symmetric algebra of dual real jet slots, indexed by multisets of + spacetime indices. -/ +noncomputable def dualRealJetAlgebraBasis : + Basis (Multiset (Fin 1 ⊕ Fin 3)) ℝ (SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector)) := + Lorentz.CoVector.basis.dualBasis.symmetricAlgebra.reindex Multiset.toFinsupp.toEquiv.symm + +/-- The multiset basis of the dual derivative symbols, as a basis vector of the + symmetric algebra at the corresponding multi-index. -/ +lemma dualRealJetAlgebraBasis_apply (s : Multiset (Fin 1 ⊕ Fin 3)) : + dualRealJetAlgebraBasis s = + Lorentz.CoVector.basis.dualBasis.symmetricAlgebra (Multiset.toFinsupp s) := by + rw [dualRealJetAlgebraBasis, Basis.reindex_apply, Equiv.symm_symm] + rfl + +/-- The multiset basis vectors of the real dual derivative slots multiply by adding the + multisets. -/ +lemma dualRealJetAlgebraBasis_mul (s t : Multiset (Fin 1 ⊕ Fin 3)) : + dualRealJetAlgebraBasis s * dualRealJetAlgebraBasis t = + dualRealJetAlgebraBasis (s + t) := by + rw [dualRealJetAlgebraBasis_apply, dualRealJetAlgebraBasis_apply, + dualRealJetAlgebraBasis_apply, map_add] + simp only [Basis.symmetricAlgebra, Basis.map_apply, + show ∀ p, (SymmetricAlgebra.equivMvPolynomial + Lorentz.CoVector.basis.dualBasis).symm.toLinearEquiv p = + (SymmetricAlgebra.equivMvPolynomial Lorentz.CoVector.basis.dualBasis).symm p + from fun _ => rfl, + ← map_mul, MvPolynomial.coe_basisMonomials] + simp only [MvPolynomial.monomial_mul, mul_one] + +/-- The multiset basis of the real dual derivative slots at the empty multiset is the + unit. -/ +lemma dualRealJetAlgebraBasis_nil : + dualRealJetAlgebraBasis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := by + rw [dualRealJetAlgebraBasis_apply, + show Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)) = 0 by simp, + Basis.symmetricAlgebra, Basis.map_apply, + show (SymmetricAlgebra.equivMvPolynomial + Lorentz.CoVector.basis.dualBasis).symm.toLinearEquiv + ((MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℝ) 0) = + (SymmetricAlgebra.equivMvPolynomial Lorentz.CoVector.basis.dualBasis).symm + ((MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℝ) 0) from rfl, + show (MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℝ) (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) + = 1 from by + rw [MvPolynomial.coe_basisMonomials] + show MvPolynomial.monomial 0 1 = 1 + rw [MvPolynomial.monomial_zero', MvPolynomial.C_1], + map_one] + +/-- The multiset basis of the real dual derivative slots at a singleton index. -/ +lemma dualRealJetAlgebraBasis_singleton (μ : Fin 1 ⊕ Fin 3) : + dualRealJetAlgebraBasis ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = + SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) + (Lorentz.CoVector.basis.dualBasis μ) := by + have h : (MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℝ) (Finsupp.single μ 1) = + MvPolynomial.X μ := rfl + rw [dualRealJetAlgebraBasis, Basis.reindex_apply, Equiv.symm_symm, + show Multiset.toFinsupp.toEquiv ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = + Finsupp.single μ 1 by simp, + Basis.symmetricAlgebra, Basis.map_apply, h] + simp + +noncomputable def RealBosonJetComponentSpace.basis : + Basis L.RealBosonJetGenerator ℝ L.RealBosonJetComponentSpace := + (dualRealJetAlgebraBasis.tensorProduct + (Pi.basis fun φ => L.realBosonBasis φ).dualBasis).reindex + realBosonJetGeneratorEquiv.symm + +/-! + +### C.4. The representation of the Lorentz group on real bosonic vector spaces and algebras + +-/ + +/-- The representation of the Lorentz group on the real Lorentz-covector derivative + slots, obtained from the real Lorentz-vector representation through the covering + map `SL(2,ℂ) →* LorentzGroup 3`. -/ +noncomputable def realBosonSlotRepLorentzGroup : Representation ℝ SL(2,ℂ) Lorentz.CoVector := + MonoidHom.comp Lorentz.CoVector.rep Lorentz.SL2C.toLorentzGroup + +/-- The representation of the Lorentz group on the symmetric algebra of real jet + coordinate slots. -/ +noncomputable def realJetAlgebraRepLorentzGroup : + Representation ℝ SL(2,ℂ) (SymmetricAlgebra ℝ Lorentz.CoVector) where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +/-- The representation of the Lorentz group on the symmetric algebra of dual real + jet coordinate slots. -/ +noncomputable def dualRealJetAlgebraRepLorentzGroup : + Representation ℝ SL(2,ℂ) (SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector)) where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup.dual Λ)).toLinearMap + map_one' := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup.dual 1) = + AlgHom.id ℝ (SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + rfl + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup.dual (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup.dual Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ realBosonSlotRepLorentzGroup.dual Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +def RealBosonTargetSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonTargetSpace where + toFun Λ := LinearMap.piMap fun φ => L.realBosonRepLorentzGroup φ Λ + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' Λ1 Λ2 := by + ext x i y + simp + +/-- The representation of the Lorentz group on the jet space of the real bosonic + fields: the tensor product of the action on the derivative slots and the action on + the real bosonic target space. -/ +noncomputable def RealBosonJetSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonJetSpace := + realJetAlgebraRepLorentzGroup.tprod RealBosonTargetSpace.repLorentzGroup + +noncomputable def RealBosonComponentSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonComponentSpace := + RealBosonTargetSpace.repLorentzGroup.dual + +noncomputable def RealBosonJetComponentSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonJetComponentSpace := + dualRealJetAlgebraRepLorentzGroup.tprod RealBosonTargetSpace.repLorentzGroup.dual + +noncomputable def RealBosonEFTExclDeriv.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonEFTExclDeriv where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repLorentzGroup (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repLorentzGroup Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repLorentzGroup Λ2)) by + rw [h]; rfl + ext v + simp + +/-- The representation of the Lorentz group on the algebra `RealBosonEFTJet`. -/ +noncomputable def RealBosonEFTJet.repLorentzGroup : + Representation ℝ SL(2,ℂ) L.RealBosonEFTJet where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repLorentzGroup (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repLorentzGroup Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repLorentzGroup Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + + +/-- The representation of the Lorentz group on the complexified real bosonic EFT + algebra, obtained from the real representation by extension of scalars and + transported to the wrapper type. -/ +noncomputable def RealBosonEFTExclDerivComplex.repLorentzGroup : + Representation ℂ SL(2,ℂ) (RealBosonEFTExclDerivComplex L) where + toFun Λ := + LinearMap.baseChange ℂ (RealBosonEFTExclDeriv.repLorentzGroup Λ) + map_one' := by + ext x + simp [Module.End.one_eq_id] + map_mul' Λ1 Λ2 := by + ext x + simp [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp] + +/-- The representation of the Lorentz group on the complexified real bosonic EFT + algebra with derivatives, obtained from the real representation by extension of + scalars. -/ +noncomputable def RealBosonEFTJetComplex.repLorentzGroup : + Representation ℂ SL(2,ℂ) (RealBosonEFTJetComplex L) where + toFun Λ := + LinearMap.baseChange ℂ (RealBosonEFTJet.repLorentzGroup Λ) + map_one' := by + ext x + simp [Module.End.one_eq_id] + map_mul' Λ1 Λ2 := by + ext x + simp [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp] + + +/-! + +### C.5. The representation of the Gauge group on real bosonic vector spaces and algebras + +-/ + +def RealBosonTargetSpace.repGaugeGroup : + Representation ℝ G L.RealBosonTargetSpace where + toFun g := LinearMap.piMap fun φ => L.realBosonRepGaugeGroup φ g + map_one' := by + ext x i y + simp only [map_one, LinearMap.coe_comp, LinearMap.coe_piMap, LinearMap.coe_single, + Function.comp_apply, Pi.map_apply, End.one_apply] + map_mul' g1 g2 := by + ext x i y + simp + +/-- The representation of the gauge group on the jet space of the real bosonic + fields. The gauge group acts trivially on the derivative slots, so that the jet + coordinates `∂ ⋯ ∂ B` transform in the same representation of the gauge group as + `B` itself. -/ +noncomputable def RealBosonJetSpace.repGaugeGroup : + Representation ℝ G L.RealBosonJetSpace := + (Representation.trivial ℝ G (SymmetricAlgebra ℝ Lorentz.CoVector)).tprod + RealBosonTargetSpace.repGaugeGroup + +noncomputable def RealBosonComponentSpace.repGaugeGroup : + Representation ℝ G L.RealBosonComponentSpace := + RealBosonTargetSpace.repGaugeGroup.dual + +/-- The representation of the gauge group on the space of component functions of the + real bosonic fields and their jet-bundle derivative coordinates; trivial on the + derivative slots. -/ +noncomputable def RealBosonJetComponentSpace.repGaugeGroup : + Representation ℝ G L.RealBosonJetComponentSpace := + (Representation.trivial ℝ G (SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector))).tprod + RealBosonTargetSpace.repGaugeGroup.dual + +noncomputable def RealBosonEFTExclDeriv.repGaugeGroup : + Representation ℝ G L.RealBosonEFTExclDeriv where + toFun g := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repGaugeGroup g)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' g1 g2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repGaugeGroup (g1 * g2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repGaugeGroup g1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonComponentSpace.repGaugeGroup g2)) by + rw [h]; rfl + ext v + simp + +noncomputable def RealBosonEFTJet.repGaugeGroup : + Representation ℝ G L.RealBosonEFTJet where + toFun g := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repGaugeGroup g)).toLinearMap + map_one' := by + simp [End.one_eq_id] + map_mul' g1 g2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repGaugeGroup (g1 * g2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repGaugeGroup g1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ RealBosonJetComponentSpace.repGaugeGroup g2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +noncomputable def RealBosonEFTExclDerivComplex.repGaugeGroup : + Representation ℂ G (RealBosonEFTExclDerivComplex L) where + toFun g := + LinearMap.baseChange ℂ (RealBosonEFTExclDeriv.repGaugeGroup g) + map_one' := by + ext x + simp [Module.End.one_eq_id] + map_mul' g1 g2 := by + ext x + simp [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp] + +/-- The representation of the gauge group on the complexified real bosonic EFT + algebra with derivatives, obtained from the real representation by extension of + scalars. -/ +noncomputable def RealBosonEFTJetComplex.repGaugeGroup : + Representation ℂ G (RealBosonEFTJetComplex L) where + toFun g := + LinearMap.baseChange ℂ (RealBosonEFTJet.repGaugeGroup g) + map_one' := by + ext x + simp [Module.End.one_eq_id] + map_mul' g1 g2 := by + ext x + simp [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp] + +/-! + +## D. General field generators + +-/ + + +inductive FieldGenerators (L : LagrangianTheory G) + | cScalar (_ : L.ComplexScalarGenerator) : FieldGenerators L + | fermion (_ : L.FermionicGenerator) : FieldGenerators L + | realBoson (_ : L.RealBosonGenerator) : FieldGenerators L +deriving DecidableEq, Fintype + +def FieldGenerators.IsFermion : L.FieldGenerators → Bool + | .cScalar _ => False + | .fermion _ => True + | .realBoson _ => False + +def FieldGenerators.IsBoson : L.FieldGenerators → Bool + | .cScalar _ => True + | .fermion _ => False + | .realBoson _ => True + +def FieldGenerators.conjugate : L.FieldGenerators → L.FieldGenerators + | .cScalar g => .cScalar g.conjugate + | .fermion g => .fermion g.conjugate + | .realBoson g => .realBoson g + +@[simp] +lemma FieldGenerators.conjugate_conjugate (ϕ : L.FieldGenerators) : + ϕ.conjugate.conjugate = ϕ := by + cases ϕ <;> simp [conjugate] + +@[simp] +lemma FieldGenerators.cScalar_isFermion (ϕ : L.ComplexScalarGenerator) : + (cScalar ϕ).IsFermion = False := by simp [IsFermion] + +@[simp] +lemma FieldGenerators.fermion_isFermion (ϕ : L.FermionicGenerator) : + (fermion ϕ).IsFermion = True := by simp [IsFermion] + +@[simp] +lemma FieldGenerators.cScalar_isBoson (ϕ : L.ComplexScalarGenerator) : + (cScalar ϕ).IsBoson = True := by simp [IsBoson] + +@[simp] +lemma FieldGenerators.fermion_isBoson (ϕ : L.FermionicGenerator) : + (fermion ϕ).IsBoson = False := by simp [IsBoson] + + +end LagrangianTheory diff --git a/Physlib/Particles/QED/Basic.lean b/Physlib/Particles/QED/Basic.lean new file mode 100644 index 000000000..0a599bd49 --- /dev/null +++ b/Physlib/Particles/QED/Basic.lean @@ -0,0 +1,1519 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Electromagnetism.Kinematics.GaugeTransformation +public import Physlib.Electromagnetism.Dynamics.KineticTerm +public import Physlib.Relativity.SL2C.Basic +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic +public import Mathlib.LinearAlgebra.Finsupp.LSum +public import Mathlib.Data.Multiset.Antidiagonal +public import Mathlib.RingTheory.TensorProduct.Maps +public import Mathlib.Algebra.MvPolynomial.Derivation +public import Mathlib.Algebra.TrivSqZeroExt.Basic +/-! +# The jet algebras of quantum electrodynamics + +## i. Overview + +This file contains *all the definitions* of the jet-algebra formulation of +quantum electrodynamics: the jet algebras of the photon and of the Dirac +electron, their tensor product — the QED jet algebra — the data of a gauge +transformation as seen by jets, the gauge actions on all three algebras, and +the evaluation of the photon jet algebra on an honest electromagnetic +potential. + +The *fields* of QED (the jet coordinates, the field strength, the γ matrices +and the covariant derivatives) are defined on top of these algebras in +`Physlib.Particles.QED.Fields`, and the Lagrangian in `Physlib.Particles.QED.Lagrangian`. All +theorems about them are proved in the definition-free files +`Physlib.Particles.QED.FermionStatistics`, `Physlib.Particles.QED.FieldStrength`, +`Physlib.Particles.QED.GammaMatrices`, `Physlib.Particles.QED.GaugeInvariance` and +`Physlib.Particles.QED.Evaluation`. + +The design choices: + +* The photon jet algebra is the free commutative algebra on formal symbols + `∂_s A_μ`, one for every multiset `s` of spacetime directions and every + Lorentz index `μ`, built directly on the electromagnetic potential of + `Physlib.Electromagnetism`. It deliberately does *not* use + `Physlib.Particles.StandardModel.GaugeBosons.BBoson`: the `B` boson is the + gauge boson of `U(1)_Y` before electroweak symmetry breaking, the photon is + the mixed combination `A = cos θ_W B + sin θ_W W³`, and the two are not the + same field. Building directly on `ElectromagneticPotential` also avoids + inheriting the Standard Model charge normalisation `6Y`, which has no + meaning for `U(1)_em`. + +* The electron jet algebra is the free *exterior* algebra on formal symbols + `∂_s ψ_α`, `∂_s ψ̄_α` with `α : Fin 2 ⊕ Fin 2` a Dirac index in the chiral + representation; the exterior product implements fermionic statistics. A + faithful QED matter sector needs a *Dirac* electron — equivalently two Weyl + spinors of the same chirality with charges `±1` — which is what makes the + dimension-three mass term `m ψ̄ ψ` possible; a single Weyl fermion admits no + such term. + +* A gauge transformation is recorded by its jets: the derivative jets + `∂_s χ` of the real gauge function together with the derivative jets + `∂_s (exp (I e χ))` of its unitary phase, related by the formal Leibniz + identity `∂_μ u = I e (∂_μ χ) u`. The action on the photon coordinates is + the affine shift `∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`, and on the electron + coordinates the Leibniz expansion of `∂_s (ū ψ)` over + `Multiset.antidiagonal s`, whose multiplicities are exactly the multinomial + coefficients of the Leibniz rule. + +This construction mirrors `Physlib.Particles.LeptonGaugeSector`, where the +analogous algebra for a single charged Weyl fermion is built from +representation-theoretic data. + +## ii. Key results + +- `Photon.JetGenerators`, `Photon.JetAlgebra`, `Photon.JetAlgebra.coord` : + the photon jet coordinates `∂_s A_μ` and their polynomial algebra. +- `Photon.JetAlgebra.gaugeAction` : the affine gauge action on the photon jet + algebra. +- `Photon.JetAlgebra.evalPotential` : the evaluation of the photon jet + algebra on an electromagnetic potential. +- `GaugeJet` : the jets of a `U(1)_em` gauge transformation with coupling `e`. +- `Electron.JetGenerators`, `Electron.JetAlgebra` : the electron jet + coordinates `∂_s ψ_α`, `∂_s ψ̄_α` and their exterior algebra. +- `Electron.JetAlgebra.gaugeAction` : the Leibniz gauge action on the + electron jet algebra. +- `JetAlgebra` : the QED jet algebra, the tensor product of the complexified + photon jet algebra with the electron jet algebra. +- `JetAlgebra.gaugeAction` : the gauge action on the QED jet algebra. +- `JetAlgebra.lorentzAction` : the Lorentz action on the QED jet algebra, + through the covering map `Lorentz.SL2C.toLorentzGroup` on the photon factor + and the Dirac spinor representation `Electron.JetAlgebra.spinorRep` on the + electron factor. +- `JetAlgebra.massScale` : the mass-weight scaling on the QED jet algebra. + +## iii. Table of contents + +- 0. Transport of derivative indices along a Lorentz transformation +- A. The jet algebra of the photon + - A.1. The jet coordinates + - A.2. The gauge action on the photon jet algebra + - A.3. Iterated derivatives indexed by a multiset + - A.4. Evaluation on a potential + - A.5. The Lorentz action on the photon jet algebra + - A.6. The mass-weight scaling on the photon jet algebra +- B. The gauge jet of a `U(1)_em` transformation + - B.1. Low-order consequences of the Leibniz identity +- C. The jet algebra of the electron + - C.1. The jet coordinates + - C.2. The gauge action on the electron jet algebra + - C.3. The action on the low-order jet coordinates + - C.4. The Lorentz action on the electron jet algebra + - C.5. The mass-weight scaling on the electron jet algebra +- D. The jet algebra of QED + - D.1. Pure tensors and their arithmetic + - D.2. The inclusions of the two factors + - D.3. The gauge action on the QED jet algebra + - D.4. The Lorentz action on the QED jet algebra + - D.5. The mass-weight scaling on the QED jet algebra + +## iv. References + +The concrete electromagnetic side is +`Physlib/Electromagnetism/Kinematics/GaugeTransformation.lean` and +`Physlib/Electromagnetism/Dynamics/KineticTerm.lean`. + +-/ + +@[expose] public section + +namespace QED + +open Electromagnetism SpaceTime minkowskiMatrix TensorProduct +open Matrix MatrixGroups + +/-! + +## 0. Transport of derivative indices along a Lorentz transformation + +A jet coordinate carries a multiset of derivative indices, each of which +transforms with `Λ⁻¹` under a Lorentz transformation (the chain rule for +`x ↦ Λ⁻¹ x`). To sum over the transformed indices without summing over +functions on a multiset, the transport recurses along the *canonical sorted +list* of the multiset, threading the chosen indices through a continuation. + +-/ + +/-- The canonical sorted list of a multiset of spacetime directions, sorted + through `Fin 1 ⊕ Fin 3 ≃ Fin 4`. -/ +noncomputable def indexList (s : Multiset (Fin 1 ⊕ Fin 3)) : List (Fin 1 ⊕ Fin 3) := + ((s.map (finSumFinEquiv (m := 1) (n := 3))).sort).map + (finSumFinEquiv (m := 1) (n := 3)).symm + +@[simp] +lemma indexList_zero : indexList 0 = [] := by + simp [indexList] + +@[simp] +lemma indexList_singleton (μ : Fin 1 ⊕ Fin 3) : indexList {μ} = [μ] := by + simp [indexList] + +lemma mem_indexList {t : Multiset (Fin 1 ⊕ Fin 3)} {a : Fin 1 ⊕ Fin 3} : + a ∈ indexList t ↔ a ∈ t := by + simp only [indexList, List.mem_map, Multiset.mem_sort, Multiset.mem_map] + constructor + · rintro ⟨b, ⟨c, hc, rfl⟩, rfl⟩ + simpa using hc + · intro ha + exact ⟨finSumFinEquiv a, ⟨a, ha, rfl⟩, by simp⟩ + +lemma indexList_length (t : Multiset (Fin 1 ⊕ Fin 3)) : + (indexList t).length = Multiset.card t := by + simp [indexList, Multiset.length_sort] + +/-- The canonical representative of a nonempty multiset of spacetime + directions: the head of its canonical sorted list. -/ +noncomputable def classRep (t : Multiset (Fin 1 ⊕ Fin 3)) : Fin 1 ⊕ Fin 3 := + (indexList t).headI + +lemma classRep_mem {t : Multiset (Fin 1 ⊕ Fin 3)} (ht : t ≠ 0) : classRep t ∈ t := by + have hne : indexList t ≠ [] := by + intro h + refine ht (Multiset.card_eq_zero.mp ?_) + rw [← indexList_length t, h, List.length_nil] + rw [← mem_indexList, classRep] + cases hl : indexList t with + | nil => exact absurd hl hne + | cons a l => simp + +attribute [irreducible] classRep + +/-- The Lorentz transport of a family indexed by derivative multisets along a + list of derivative directions: each direction in the list is summed against + a row of `Λ⁻¹`, and the chosen directions accumulate in the multiset + argument of the continuation `k`. -/ +noncomputable def derivSum {M : Type*} [AddCommMonoid M] [Module ℝ M] + (Λ : LorentzGroup 3) : + List (Fin 1 ⊕ Fin 3) → (Multiset (Fin 1 ⊕ Fin 3) → M) → M + | [], k => k 0 + | σ :: l, k => ∑ τ, (Λ⁻¹).1 τ σ • derivSum Λ l fun t => k (t + {τ}) + +@[simp] +lemma derivSum_nil {M : Type*} [AddCommMonoid M] [Module ℝ M] + (Λ : LorentzGroup 3) (k : Multiset (Fin 1 ⊕ Fin 3) → M) : + derivSum Λ [] k = k 0 := rfl + +@[simp] +lemma derivSum_cons {M : Type*} [AddCommMonoid M] [Module ℝ M] + (Λ : LorentzGroup 3) (σ : Fin 1 ⊕ Fin 3) (l : List (Fin 1 ⊕ Fin 3)) + (k : Multiset (Fin 1 ⊕ Fin 3) → M) : + derivSum Λ (σ :: l) k = + ∑ τ, (Λ⁻¹).1 τ σ • derivSum Λ l fun t => k (t + {τ}) := rfl + +namespace Photon + +/-! + +## A. The jet algebra of the photon + +### A.1. The jet coordinates + +A jet coordinate is a formal symbol `∂_s A_μ`, where `s` is a *multiset* of +spacetime directions: for a smooth potential the partial derivatives commute, +so only the number of times each direction occurs matters. The jet algebra is +the algebra of real polynomials in these symbols. + +-/ + +/-- The jet coordinates of the electromagnetic potential: the symbol `∂_s A_μ`, + the `s`-th derivative of the `μ`-th covariant component. -/ +inductive JetGenerators where + /-- The jet coordinate `∂_s A_μ`. -/ + | dA (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : JetGenerators + deriving DecidableEq + +/-- The mass weight (twice the mass dimension) of a photon jet coordinate: + the potential has mass dimension one and each derivative adds one. -/ +def JetGenerators.massWeight : JetGenerators → ℕ + | .dA s _ => 2 + 2 * s.card + +/-- The symmetrized-index class of a photon jet coordinate: under a gauge + transformation `∂_s A_μ` shifts by `∂_s ∂_μ χ`, which depends only on the + multiset `s + {μ}`. Coordinates in a common class shift together. -/ +def JetGenerators.indexClass : JetGenerators → Multiset (Fin 1 ⊕ Fin 3) + | .dA s μ => s + {μ} + +/-- The canonical jet coordinate of a symmetrized-index class: the coordinate + whose Lorentz index is the canonical representative of the class. -/ +noncomputable def JetGenerators.classProj (j : JetGenerators) : JetGenerators := + .dA (j.indexClass.erase (classRep j.indexClass)) (classRep j.indexClass) + +/-- The jet algebra of the photon: real polynomials in the jet coordinates. -/ +abbrev JetAlgebra : Type := MvPolynomial JetGenerators ℝ + +namespace JetAlgebra + +/-- The jet coordinate `∂_s A_μ` as an element of the jet algebra. -/ +noncomputable def coord (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : JetAlgebra := + MvPolynomial.X (JetGenerators.dA s μ) + +/-! + +### A.2. The gauge action on the photon jet algebra + +A `U(1)_em` gauge transformation sends `A_μ ↦ A_μ + ∂_μ χ`, hence on jet +coordinates `∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`. All that the photon jet algebra +sees of the gauge function `χ` is the family of its symmetrised derivatives at +the base point, which is what `GaugeJet` records; the shift of `∂_s A_μ` is +then the value of that family at `s + {μ}`. + +-/ + +/-- A photon gauge jet: the family `s ↦ ∂_s χ` of symmetrised derivatives of a + gauge function at the base point. This is all the photon jet algebra sees of + a gauge transformation. -/ +abbrev GaugeJet : Type := Multiset (Fin 1 ⊕ Fin 3) → ℝ + +/-- The gauge action on the photon jet algebra: the algebra map determined by + `∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`. -/ +noncomputable def gaugeAction (c : GaugeJet) : JetAlgebra →ₐ[ℝ] JetAlgebra := + MvPolynomial.aeval fun j => match j with + | JetGenerators.dA s μ => coord s μ + MvPolynomial.C (c (s + {μ})) + +@[simp] +lemma gaugeAction_coord (c : GaugeJet) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + gaugeAction c (coord s μ) = coord s μ + MvPolynomial.C (c (s + {μ})) := by + rw [coord, gaugeAction, MvPolynomial.aeval_X] + rfl + +@[simp] +lemma gaugeAction_C (c : GaugeJet) (r : ℝ) : + gaugeAction c (MvPolynomial.C r) = MvPolynomial.C r := by + rw [gaugeAction, MvPolynomial.aeval_C, MvPolynomial.algebraMap_eq] + +/-! + +### A.3. Iterated derivatives indexed by a multiset + +To evaluate a jet coordinate on a potential we must differentiate along a +multiset of directions, so we must choose an order; we choose the canonical +one, sorting `s` through `Fin 1 ⊕ Fin 3 ≃ Fin 4`. For a `C^∞` potential the +choice is immaterial, by Clairaut's theorem (`SpaceTime.deriv_commute`). + +-/ + +/-- The iterated partial derivative `∂_s f` along a multiset `s` of spacetime + directions, taken in the canonical order obtained by sorting `s`. -/ +noncomputable def derivMultiset (s : Multiset (Fin 1 ⊕ Fin 3)) (f : SpaceTime 3 → ℝ) : + SpaceTime 3 → ℝ := + ((s.map (finSumFinEquiv (m := 1) (n := 3))).sort).foldr + (fun i g => ∂_ ((finSumFinEquiv (m := 1) (n := 3)).symm i) g) f + +@[simp] +lemma derivMultiset_zero (f : SpaceTime 3 → ℝ) : derivMultiset 0 f = f := by + simp [derivMultiset] + +@[simp] +lemma derivMultiset_singleton (μ : Fin 1 ⊕ Fin 3) (f : SpaceTime 3 → ℝ) : + derivMultiset {μ} f = ∂_ μ f := by + simp [derivMultiset] + +/-! + +### A.4. Evaluation on a potential + +`ElectromagneticPotential` stores the contravariant components `A^μ`, whereas +a gauge potential carries a lower index, so the jet coordinate `∂_s A_μ` +evaluates to the `s`-th derivative of `A_μ = η_{μμ} A^μ`. + +-/ + +/-- The covariant components `A_μ = η_{μμ} A^μ` of an electromagnetic potential. -/ +noncomputable def coPotential (A : ElectromagneticPotential 3) (μ : Fin 1 ⊕ Fin 3) : + SpaceTime 3 → ℝ := fun x => η μ μ * A x μ + +/-- The evaluation of the photon jet algebra at an electromagnetic potential `A`: + the algebra map sending the formal jet coordinate `∂_s A_μ` to the honest + function `∂_s A_μ` on spacetime. -/ +noncomputable def evalPotential (A : ElectromagneticPotential 3) : + JetAlgebra →ₐ[ℝ] (SpaceTime 3 → ℝ) := + MvPolynomial.aeval fun j => match j with + | JetGenerators.dA s μ => derivMultiset s (coPotential A μ) + +@[simp] +lemma evalPotential_coord (A : ElectromagneticPotential 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) : + evalPotential A (coord s μ) = derivMultiset s (coPotential A μ) := by + rw [coord, evalPotential, MvPolynomial.aeval_X] + +/-! + +### A.5. The Lorentz action on the photon jet algebra + +Under a Lorentz transformation the potential transforms as a covector field, +`A'(x) = (Λ⁻¹)ᵀ A (Λ⁻¹ x)`, so every lower index of the jet coordinate +`∂_s A_μ` — the index `μ` and each derivative index in `s` — is summed +against a row of `Λ⁻¹`. + +-/ + +/-- The Lorentz action on the photon jet algebra: the algebra map transporting + every lower index of `∂_s A_μ` with `Λ⁻¹`. -/ +noncomputable def lorentzAction (Λ : LorentzGroup 3) : JetAlgebra →ₐ[ℝ] JetAlgebra := + MvPolynomial.aeval fun j => match j with + | JetGenerators.dA s μ => + derivSum Λ (indexList s) fun t => ∑ ν, (Λ⁻¹).1 ν μ • coord t ν + +@[simp] +lemma lorentzAction_coord (Λ : LorentzGroup 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) : + lorentzAction Λ (coord s μ) = + derivSum Λ (indexList s) fun t => ∑ ν, (Λ⁻¹).1 ν μ • coord t ν := by + rw [coord, lorentzAction, MvPolynomial.aeval_X] + +lemma lorentzAction_coord_zero (Λ : LorentzGroup 3) (μ : Fin 1 ⊕ Fin 3) : + lorentzAction Λ (coord 0 μ) = ∑ ν, (Λ⁻¹).1 ν μ • coord 0 ν := by + rw [lorentzAction_coord, indexList_zero, derivSum_nil] + +lemma lorentzAction_coord_singleton (Λ : LorentzGroup 3) (σ μ : Fin 1 ⊕ Fin 3) : + lorentzAction Λ (coord {σ} μ) = + ∑ τ, ∑ ν, ((Λ⁻¹).1 τ σ * (Λ⁻¹).1 ν μ) • coord {τ} ν := by + rw [lorentzAction_coord, indexList_singleton, derivSum_cons] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [derivSum_nil, Finset.smul_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [smul_smul, zero_add] + +/-! + +### A.6. The mass-weight scaling on the photon jet algebra + +-/ + +/-- The mass-weight scaling on the photon jet algebra: the algebra map + multiplying each jet coordinate by `c` to the power of its mass weight. -/ +noncomputable def massScale (c : ℝ) : JetAlgebra →ₐ[ℝ] JetAlgebra := + MvPolynomial.aeval fun j => c ^ j.massWeight • MvPolynomial.X j + +@[simp] +lemma massScale_coord (c : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + massScale c (coord s μ) = c ^ (2 + 2 * Multiset.card s) • coord s μ := by + rw [coord, massScale, MvPolynomial.aeval_X] + rfl + +/-! + +### A.7. The formal total derivative on the photon jet algebra + +-/ + +/-- The formal total spacetime derivative on the photon jet algebra in the + direction `ρ`: the derivation appending the derivative index, + `∂_s A_μ ↦ ∂_{s + {ρ}} A_μ`. -/ +noncomputable def jetDeriv (ρ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℝ] JetAlgebra := + (MvPolynomial.mkDerivation ℝ fun j => match j with + | JetGenerators.dA s μ => coord (s + {ρ}) μ : Derivation ℝ JetAlgebra JetAlgebra) + +@[simp] +lemma jetDeriv_coord (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) : + jetDeriv ρ (coord s μ) = coord (s + {ρ}) μ := by + rw [coord] + exact MvPolynomial.mkDerivation_X _ _ _ + +@[simp] +lemma jetDeriv_one (ρ : Fin 1 ⊕ Fin 3) : jetDeriv ρ (1 : JetAlgebra) = 0 := + Derivation.map_one_eq_zero _ + +/-- The total derivative is a derivation on the photon jet algebra. -/ +lemma jetDeriv_mul (ρ : Fin 1 ⊕ Fin 3) (x y : JetAlgebra) : + jetDeriv ρ (x * y) = jetDeriv ρ x * y + x * jetDeriv ρ y := by + have h : jetDeriv ρ (x * y) = x • jetDeriv ρ y + y • jetDeriv ρ x := + Derivation.leibniz _ x y + rw [h, smul_eq_mul, smul_eq_mul] + ring + +/-- The Leibniz rule for the complexified total derivative. -/ +lemma jetDeriv_baseChange_mul (ρ : Fin 1 ⊕ Fin 3) (x y : ℂ ⊗[ℝ] JetAlgebra) : + LinearMap.baseChange ℂ (jetDeriv ρ) (x * y) = + LinearMap.baseChange ℂ (jetDeriv ρ) x * y + + x * LinearMap.baseChange ℂ (jetDeriv ρ) y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => + simp only [add_mul, map_add, ha, hb] + abel + | tmul c p => + induction y using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => + simp only [mul_add, map_add, ha, hb] + abel + | tmul c' p' => + simp only [Algebra.TensorProduct.tmul_mul_tmul, LinearMap.baseChange_tmul, + jetDeriv_mul, TensorProduct.tmul_add] + +end JetAlgebra + +end Photon + +/-! + +## B. The gauge jet of a `U(1)_em` transformation + +A gauge transformation with gauge function `χ` acts on the photon by +`A_μ ↦ A_μ + ∂_μ χ` and on a field of charge `q` by `ψ ↦ exp (I q e χ) ψ`. +All that the jet algebras see of `χ` are its derivative jets `c s = ∂_s χ`, +and all they see of the phase are the derivative jets +`u s = ∂_s (exp (I e χ))`. The two families are not independent: +differentiating the exponential gives `∂_μ u = I e (∂_μ χ) u`, whose `s`-th +derivative is a Leibniz sum over the splittings of `s`. +`Multiset.antidiagonal` counts each splitting with its multiplicity, which is +exactly the multinomial weight of the Leibniz rule. + +-/ + +/-- Summing an indicator supported on the splittings `(0, t)` over the + antidiagonal of `t` picks out `f t`: the splitting `(0, t)` occurs exactly + once in `Multiset.antidiagonal t`. -/ +lemma sum_map_antidiagonal_ite {M : Type*} [AddCommMonoid M] + (t : Multiset (Fin 1 ⊕ Fin 3)) (f : Multiset (Fin 1 ⊕ Fin 3) → M) : + ((t.antidiagonal).map fun p => if p.1 = 0 then f p.2 else 0).sum = f t := by + induction t using Multiset.induction_on generalizing f with + | empty => simp + | cons a s ih => + rw [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Multiset.map_map] + have h2 : ((s.antidiagonal).map + ((fun p => if p.1 = 0 then f p.2 else 0) ∘ + Prod.map (Multiset.cons a) id)).sum = 0 := + Multiset.sum_eq_zero fun x hx => by + obtain ⟨p, _, rfl⟩ := Multiset.mem_map.mp hx + simp + rw [h2, add_zero, + show ((fun p => if p.1 = 0 then f p.2 else 0) ∘ Prod.map id (Multiset.cons a)) = + fun p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3) => + if p.1 = 0 then f (a ::ₘ p.2) else 0 from rfl] + exact ih fun u => f (a ::ₘ u) + +/-- The Leibniz convolution of a phase family against a module-valued family + of jets, over the antidiagonal of the derivative multiset: the formal + expansion `∂_s (u ⬝ f) = ∑_{x + y = s} (∂_x u) (∂_y f)`, with the + multiplicities of `Multiset.antidiagonal` supplying the multinomial + weights. -/ +noncomputable def phaseAct {M : Type*} [AddCommMonoid M] [Module ℂ M] + (u : Multiset (Fin 1 ⊕ Fin 3) → ℂ) (f : Multiset (Fin 1 ⊕ Fin 3) → M) : + Multiset (Fin 1 ⊕ Fin 3) → M := + fun s => (s.antidiagonal.map fun p => u p.1 • f p.2).sum + +section PhaseAct + +variable {M : Type*} [AddCommMonoid M] [Module ℂ M] +variable (u u₁ u₂ v : Multiset (Fin 1 ⊕ Fin 3) → ℂ) +variable (f g : Multiset (Fin 1 ⊕ Fin 3) → M) + +@[simp] +lemma phaseAct_zero_arg : phaseAct u f 0 = u 0 • f 0 := by + simp [phaseAct] + +/-- The convolution as a literal antidiagonal sum of products, for + scalar-valued families. -/ +lemma phaseAct_eq_sum (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u v s = (s.antidiagonal.map fun p => u p.1 * v p.2).sum := rfl + +/-- The Leibniz rule of the convolution: differentiating a convolution + differentiates one factor at a time. -/ +lemma phaseAct_add_singleton (a : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u f (s + {a}) = + phaseAct u (fun t => f (t + {a})) s + + phaseAct (fun t => u (t + {a})) f s := by + rw [phaseAct, show s + {a} = a ::ₘ s from by + rw [Multiset.add_comm, Multiset.singleton_add], + Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Multiset.map_map] + congr 1 + · refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + rw [Multiset.add_comm, Multiset.singleton_add] + · refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + rw [Multiset.add_comm, Multiset.singleton_add] + +lemma phaseAct_add_left (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct (fun t => u₁ t + u₂ t) f s = phaseAct u₁ f s + phaseAct u₂ f s := by + rw [phaseAct, phaseAct, phaseAct, ← Multiset.sum_map_add] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => add_smul _ _ _) + +lemma phaseAct_add_right (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u (fun t => f t + g t) s = phaseAct u f s + phaseAct u g s := by + rw [phaseAct, phaseAct, phaseAct, ← Multiset.sum_map_add] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => smul_add _ _ _) + +lemma phaseAct_smul_left (c : ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct (fun t => c * u t) f s = c • phaseAct u f s := by + rw [phaseAct, phaseAct, Multiset.smul_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply] + exact mul_smul _ _ _ + +lemma phaseAct_smul_right (c : ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u (fun t => c • f t) s = c • phaseAct u f s := by + rw [phaseAct, phaseAct, Multiset.smul_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply] + exact smul_comm _ _ _ + +/-- Associativity of the convolution: acting by `u` after `v` is acting by + the convolution `u ⋆ v`. -/ +lemma phaseAct_assoc (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u (phaseAct v f) s = phaseAct (phaseAct u v) f s := by + induction s using Multiset.induction_on generalizing u v f with + | empty => + simp [smul_smul] + | cons a s ih => + rw [show a ::ₘ s = s + {a} from by + rw [Multiset.add_comm, Multiset.singleton_add]] + rw [phaseAct_add_singleton, phaseAct_add_singleton, + show (fun t => phaseAct v f (t + {a})) = fun t => + phaseAct v (fun t' => f (t' + {a})) t + + phaseAct (fun t' => v (t' + {a})) f t from + funext fun t => phaseAct_add_singleton v f a t, + phaseAct_add_right, ih, ih, ih, + show (fun t => phaseAct u v (t + {a})) = fun t => + phaseAct u (fun t' => v (t' + {a})) t + + phaseAct (fun t' => u (t' + {a})) v t from + funext fun t => phaseAct_add_singleton u v a t, + phaseAct_add_left] + abel + +/-- Commutativity of the scalar convolution. -/ +lemma phaseAct_comm (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct u v s = phaseAct v u s := by + induction s using Multiset.induction_on generalizing u v with + | empty => simp [smul_eq_mul, mul_comm] + | cons a s ih => + rw [show a ::ₘ s = s + {a} from by + rw [Multiset.add_comm, Multiset.singleton_add]] + rw [phaseAct_add_singleton, phaseAct_add_singleton, + ih u fun t => v (t + {a}), ih (fun t => u (t + {a})) v] + exact add_comm (phaseAct (fun t => v (t + {a})) u s) + (phaseAct v (fun t => u (t + {a})) s) + +/-- A linear map passes through the convolution. -/ +lemma map_phaseAct {N : Type*} [AddCommMonoid N] [Module ℂ N] (L : M →ₗ[ℂ] N) + (s : Multiset (Fin 1 ⊕ Fin 3)) : + L (phaseAct u f s) = phaseAct u (fun t => L (f t)) s := by + rw [phaseAct, phaseAct, map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => map_smul L _ _) + +/-- The convolution against the indicator of the empty multiset is the + identity: the splitting `(0, t)` occurs exactly once in the + antidiagonal. -/ +lemma phaseAct_indicator (s : Multiset (Fin 1 ⊕ Fin 3)) : + phaseAct (fun t => if t = 0 then 1 else 0) f s = f s := by + rw [phaseAct, show (s.antidiagonal.map fun p => + (if p.1 = 0 then (1 : ℂ) else 0) • f p.2) = + s.antidiagonal.map fun p => if p.1 = 0 then f p.2 else 0 from + Multiset.map_congr rfl fun p _ => by + by_cases h : p.1 = 0 <;> simp [h]] + exact sum_map_antidiagonal_ite s f + +/-- The star of a convolution is the convolution of the stars. -/ +lemma star_phaseAct (s : Multiset (Fin 1 ⊕ Fin 3)) : + star (phaseAct u v s) = + phaseAct (fun t => star (u t)) (fun t => star (v t)) s := by + rw [phaseAct_eq_sum, phaseAct_eq_sum, ← starRingEnd_apply, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + simp only [Function.comp_apply, map_mul, starRingEnd_apply] + +end PhaseAct + +/-- The jets of a `U(1)_em` gauge transformation with coupling `e`: the + derivative jets `χjet s = ∂_s χ` of the real gauge function and + `phase s = ∂_s (exp (I e χ))` of its unitary phase at the base point, + subject to the two identities every honest gauge function satisfies: + the phase has unit norm at the base point, and its derivatives obey the + formal Leibniz expansion of `∂_μ (exp (I e χ)) = I e (∂_μ χ) exp (I e χ)`. -/ +structure GaugeJet (e : ℝ) where + /-- The derivative jets `∂_s χ` of the gauge function. -/ + χjet : Multiset (Fin 1 ⊕ Fin 3) → ℝ + /-- The derivative jets `∂_s (exp (I e χ))` of the unitary phase. -/ + phase : Multiset (Fin 1 ⊕ Fin 3) → ℂ + /-- The phase is unitary at the base point. -/ + phase_zero_unitary : phase 0 * star (phase 0) = 1 + /-- The formal Leibniz identity `∂_s ∂_μ u = I e ∂_s ((∂_μ χ) u)`. -/ + phase_deriv : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), + phase (s + {μ}) = Complex.I * e * + ((s.antidiagonal.map fun p => (χjet (p.1 + {μ}) : ℂ) * phase p.2).sum) + +namespace GaugeJet + +variable {e : ℝ} (g : GaugeJet e) + +/-! + +### B.1. Low-order consequences of the Leibniz identity + +The QED Lagrangian only involves jet coordinates of derivative order at most +one, so its gauge invariance only uses the Leibniz identity at order zero, +together with unitarity at the base point. + +-/ + +lemma star_phase_zero_unitary : star (g.phase 0) * g.phase 0 = 1 := by + rw [mul_comm] + exact g.phase_zero_unitary + +/-- The first derivative of the phase: the `s = 0` case of the Leibniz + identity, `∂_μ u = I e (∂_μ χ) u` at the base point. -/ +lemma phase_singleton (μ : Fin 1 ⊕ Fin 3) : + g.phase {μ} = Complex.I * e * (g.χjet {μ} * g.phase 0) := by + simpa using g.phase_deriv 0 μ + +/-- The first derivative of the conjugate phase, + `∂_μ ū = -I e (∂_μ χ) ū` at the base point. -/ +lemma star_phase_singleton (μ : Fin 1 ⊕ Fin 3) : + star (g.phase {μ}) = -(Complex.I * e * (g.χjet {μ} * star (g.phase 0))) := by + rw [g.phase_singleton μ] + simp only [star_mul', Complex.star_def, Complex.conj_I, Complex.conj_ofReal] + ring + +/-- The trivial gauge jet: the jets of the constant gauge function `χ = 0`. -/ +noncomputable def trivial (e : ℝ) : GaugeJet e where + χjet := 0 + phase s := if s = 0 then 1 else 0 + phase_zero_unitary := by simp + phase_deriv s μ := by + rw [if_neg (by simp)] + rw [show ((s.antidiagonal.map fun p => + ((0 : Multiset (Fin 1 ⊕ Fin 3) → ℝ) (p.1 + {μ}) : ℂ) * + (if p.2 = 0 then (1 : ℂ) else 0)).sum) = 0 from + Multiset.sum_eq_zero fun x hx => by + obtain ⟨p, _, rfl⟩ := Multiset.mem_map.mp hx + simp] + ring + +/-! + +### B.2. The commutative monoid of gauge jets + +Gauge jets compose: the gauge functions add and the phases convolve by the +Leibniz rule. Closure of the two axioms under this product is a consistency +check on the axiomatisation of `GaugeJet`. + +-/ + +lemma ext {g₁ g₂ : GaugeJet e} (h1 : g₁.χjet = g₂.χjet) + (h2 : g₁.phase = g₂.phase) : g₁ = g₂ := by + cases g₁ + cases g₂ + simp_all + +/-- The composite of two gauge jets: the gauge functions add and the phases + convolve by the Leibniz rule. -/ +noncomputable instance : Mul (GaugeJet e) where + mul g₁ g₂ := + { χjet := g₁.χjet + g₂.χjet + phase := phaseAct g₁.phase g₂.phase + phase_zero_unitary := by + rw [phaseAct_zero_arg, smul_eq_mul, star_mul'] + calc g₁.phase 0 * g₂.phase 0 * (star (g₁.phase 0) * star (g₂.phase 0)) + = g₁.phase 0 * star (g₁.phase 0) * + (g₂.phase 0 * star (g₂.phase 0)) := by ring + _ = 1 := by rw [g₁.phase_zero_unitary, g₂.phase_zero_unitary, one_mul] + phase_deriv := by + intro s μ + rw [phaseAct_add_singleton, + show (fun t => g₂.phase (t + {μ})) = fun t => (Complex.I * e) • + phaseAct (fun x => (g₂.χjet (x + {μ}) : ℂ)) g₂.phase t from + funext fun t => by + rw [g₂.phase_deriv t μ, phaseAct_eq_sum, smul_eq_mul, mul_assoc], + show (fun t => g₁.phase (t + {μ})) = fun t => Complex.I * ↑e * + phaseAct (fun x => (g₁.χjet (x + {μ}) : ℂ)) g₁.phase t from + funext fun t => by + rw [g₁.phase_deriv t μ, phaseAct_eq_sum, mul_assoc], + phaseAct_smul_right, phaseAct_smul_left, + phaseAct_assoc g₁.phase _ g₂.phase, + show phaseAct g₁.phase (fun x => (g₂.χjet (x + {μ}) : ℂ)) = + phaseAct (fun x => (g₂.χjet (x + {μ}) : ℂ)) g₁.phase from + funext fun t => phaseAct_comm _ _ t, + ← phaseAct_assoc, ← phaseAct_assoc, ← smul_add, + show phaseAct (fun x => (g₂.χjet (x + {μ}) : ℂ)) + (phaseAct g₁.phase g₂.phase) s + + phaseAct (fun x => (g₁.χjet (x + {μ}) : ℂ)) + (phaseAct g₁.phase g₂.phase) s = + phaseAct (fun x => (((g₁.χjet + g₂.χjet) (x + {μ}) : ℝ) : ℂ)) + (phaseAct g₁.phase g₂.phase) s from by + rw [← phaseAct_add_left] + refine congrFun (congrArg + (fun w => phaseAct w (phaseAct g₁.phase g₂.phase)) + (funext fun x => ?_)) s + rw [Pi.add_apply] + push_cast + ring, + phaseAct_eq_sum, smul_eq_mul, mul_assoc] } + +@[simp] +lemma mul_χjet (g₁ g₂ : GaugeJet e) : (g₁ * g₂).χjet = g₁.χjet + g₂.χjet := rfl + +@[simp] +lemma mul_phase (g₁ g₂ : GaugeJet e) : + (g₁ * g₂).phase = phaseAct g₁.phase g₂.phase := rfl + +noncomputable instance : One (GaugeJet e) := ⟨trivial e⟩ + +@[simp] +lemma one_χjet : (1 : GaugeJet e).χjet = 0 := rfl + +@[simp] +lemma one_phase : + (1 : GaugeJet e).phase = fun s => if s = 0 then (1 : ℂ) else 0 := rfl + +/-- **The gauge jets form a commutative monoid**: the gauge symmetry data of + QED composes associatively, with the trivial gauge jet as the unit. -/ +noncomputable instance : CommMonoid (GaugeJet e) where + mul_assoc g₁ g₂ g₃ := by + refine ext (add_assoc _ _ _) (funext fun s => ?_) + exact (phaseAct_assoc g₁.phase g₂.phase g₃.phase s).symm + one_mul g := by + refine ext (zero_add _) (funext fun s => ?_) + exact phaseAct_indicator g.phase s + mul_one g := by + refine ext (add_zero _) (funext fun s => ?_) + rw [mul_phase, one_phase, phaseAct_comm] + exact phaseAct_indicator g.phase s + mul_comm g₁ g₂ := by + refine ext (add_comm _ _) (funext fun s => ?_) + exact phaseAct_comm g₁.phase g₂.phase s + +end GaugeJet + +namespace Electron + +/-! + +## C. The jet algebra of the electron + +### C.1. The jet coordinates + +A jet coordinate is a formal symbol `∂_s ψ_α` or `∂_s ψ̄_α`, where `s` is a +*multiset* of spacetime directions (partial derivatives of a smooth field +commute) and `α : Fin 2 ⊕ Fin 2` is a Dirac spinor index in the chiral +representation: `Sum.inl` indexes the left-handed and `Sum.inr` the +right-handed Weyl component. + +-/ + +/-- The jet coordinates of the Dirac electron: the symbols `∂_s ψ_α` and + `∂_s ψ̄_α`, the `s`-th derivatives of the Dirac components and their + conjugates. The electron has electric charge `-1`; its conjugate has + charge `+1`. -/ +inductive JetGenerators where + /-- The jet coordinate `∂_s ψ_α` of the electron. -/ + | dψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : JetGenerators + /-- The jet coordinate `∂_s ψ̄_α` of the conjugate electron. -/ + | dbarψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : JetGenerators + deriving DecidableEq + +/-- The mass weight (twice the mass dimension) of an electron jet coordinate: + a fermion has mass dimension `3/2` and each derivative adds one. -/ +def JetGenerators.massWeight : JetGenerators → ℕ + | .dψ s _ => 3 + 2 * s.card + | .dbarψ s _ => 3 + 2 * s.card + +/-- The jet component space of the electron: the free complex module on the + jet coordinates. -/ +abbrev JetComponentSpace : Type := JetGenerators →₀ ℂ + +/-- The jet algebra of the electron: the exterior algebra on the free module + over the jet coordinates. The exterior product implements the fermionic + anticommutativity of the electron field. -/ +abbrev JetAlgebra : Type := ExteriorAlgebra ℂ JetComponentSpace + +namespace JetAlgebra + +/-- The jet coordinate `∂_s ψ_α` or `∂_s ψ̄_α` as an element of the jet + algebra. -/ +noncomputable def ofGenerator (j : JetGenerators) : JetAlgebra := + ExteriorAlgebra.ι ℂ (Finsupp.single j 1) + +/-! + +### C.2. The gauge action on the electron jet algebra + +A gauge transformation sends the electron (charge `-1`) to `ū ψ` and its +conjugate to `u ψ̄`, where `u = exp (I e χ)`. On jet coordinates this is the +Leibniz expansion + +`∂_s ψ_α ↦ ∑_{x + y = s} (∂_x ū) (∂_y ψ_α)`, + +the sum running over `Multiset.antidiagonal s`, whose multiplicities are the +multinomial coefficients of the Leibniz rule. The action is linear on the jet +component space and extends functorially to an algebra map of the exterior +algebra. + +-/ + +/-- The gauge action on a single electron jet coordinate: the Leibniz + expansion of `∂_s (ū ψ_α)` and `∂_s (u ψ̄_α)` over the splittings of `s`. -/ +noncomputable def gaugeActionGenerator {e : ℝ} (g : GaugeJet e) : + JetGenerators → JetComponentSpace + | .dψ t α => (t.antidiagonal.map fun p => + Finsupp.single (JetGenerators.dψ p.2 α) (star (g.phase p.1))).sum + | .dbarψ t α => (t.antidiagonal.map fun p => + Finsupp.single (JetGenerators.dbarψ p.2 α) (g.phase p.1)).sum + +/-- The gauge action on the jet component space: the linear extension of the + Leibniz expansion on the jet coordinates. -/ +noncomputable def gaugeActionCS {e : ℝ} (g : GaugeJet e) : + JetComponentSpace →ₗ[ℂ] JetComponentSpace := + Finsupp.lift JetComponentSpace ℂ JetGenerators (gaugeActionGenerator g) + +@[simp] +lemma gaugeActionCS_single {e : ℝ} (g : GaugeJet e) (j : JetGenerators) : + gaugeActionCS g (Finsupp.single j 1) = gaugeActionGenerator g j := by + rw [gaugeActionCS, Finsupp.lift_apply, Finsupp.sum_single_index (by simp), one_smul] + +/-- The gauge action on the electron jet algebra: the algebra map induced by + the Leibniz expansion on the jet coordinates. -/ +noncomputable def gaugeAction {e : ℝ} (g : GaugeJet e) : + JetAlgebra →ₐ[ℂ] JetAlgebra := + ExteriorAlgebra.map (gaugeActionCS g) + +lemma gaugeAction_ofGenerator_dψ {e : ℝ} (g : GaugeJet e) + (t : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dψ t α)) = + (t.antidiagonal.map fun p => + star (g.phase p.1) • ofGenerator (.dψ p.2 α)).sum := by + rw [gaugeAction, ofGenerator, ExteriorAlgebra.map_apply_ι, gaugeActionCS_single, + gaugeActionGenerator, map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, ← Finsupp.smul_single_one, map_smul] + rfl + +lemma gaugeAction_ofGenerator_dbarψ {e : ℝ} (g : GaugeJet e) + (t : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dbarψ t α)) = + (t.antidiagonal.map fun p => + g.phase p.1 • ofGenerator (.dbarψ p.2 α)).sum := by + rw [gaugeAction, ofGenerator, ExteriorAlgebra.map_apply_ι, gaugeActionCS_single, + gaugeActionGenerator, map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p _ => ?_) + rw [Function.comp_apply, ← Finsupp.smul_single_one, map_smul] + rfl + +/-! + +### C.3. The action on the low-order jet coordinates + +The QED Lagrangian involves only the jet coordinates of derivative order at +most one, for which the antidiagonal sums are short: `antidiagonal 0` is the +single splitting `(0, 0)`, and `antidiagonal {μ}` the two splittings +`(0, {μ})` and `({μ}, 0)`. + +-/ + +lemma antidiagonal_singleton (μ : Fin 1 ⊕ Fin 3) : + ({μ} : Multiset (Fin 1 ⊕ Fin 3)).antidiagonal = {(0, {μ}), ({μ}, 0)} := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, + Multiset.antidiagonal_cons, Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.map_singleton, Multiset.singleton_add] + rfl + +@[simp] +lemma gaugeAction_ofGenerator_dψ_zero {e : ℝ} (g : GaugeJet e) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dψ 0 α)) = + star (g.phase 0) • ofGenerator (.dψ 0 α) := by + rw [gaugeAction_ofGenerator_dψ] + simp + +@[simp] +lemma gaugeAction_ofGenerator_dbarψ_zero {e : ℝ} (g : GaugeJet e) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dbarψ 0 α)) = + g.phase 0 • ofGenerator (.dbarψ 0 α) := by + rw [gaugeAction_ofGenerator_dbarψ] + simp + +lemma gaugeAction_ofGenerator_dψ_singleton {e : ℝ} (g : GaugeJet e) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dψ {μ} α)) = + star (g.phase 0) • ofGenerator (.dψ {μ} α) + + star (g.phase {μ}) • ofGenerator (.dψ 0 α) := by + rw [gaugeAction_ofGenerator_dψ, antidiagonal_singleton] + simp + +lemma gaugeAction_ofGenerator_dbarψ_singleton {e : ℝ} (g : GaugeJet e) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ofGenerator (.dbarψ {μ} α)) = + g.phase 0 • ofGenerator (.dbarψ {μ} α) + + g.phase {μ} • ofGenerator (.dbarψ 0 α) := by + rw [gaugeAction_ofGenerator_dbarψ, antidiagonal_singleton] + simp + +/-! + +### C.4. The Lorentz action on the electron jet algebra + +Under `M : SL(2,ℂ)` the Dirac spinor transforms in the chiral basis by the +block-diagonal matrix `S(M) = ((M, 0), (0, (M†)⁻¹))`, its conjugate by the +entrywise conjugate of `S(M)`, and every derivative index by `Λ(M)⁻¹`, where +`Λ(M)` is the image of `M` under the covering map +`Lorentz.SL2C.toLorentzGroup`. + +-/ + +/-- The Dirac spinor representation of `SL(2,ℂ)` in the chiral basis: the two + Weyl components transform in the two conjugate-dual fundamental + representations, `S(M) = ((M, 0), (0, (M†)⁻¹))`, the assignment being fixed + by the conventions of `Lorentz.SL2C.toLorentzGroup`. -/ +noncomputable def spinorRep (M : SL(2,ℂ)) : + Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ := + Matrix.fromBlocks M.1 0 0 ((M⁻¹).1)ᴴ + +/-- The Lorentz action on a single electron jet coordinate: the spinor index + is rotated by the spinor representation (its conjugate for `∂_s ψ̄`) and the + derivative indices are transported with `Λ(M)⁻¹`. -/ +noncomputable def lorentzActionGenerator (M : SL(2,ℂ)) : + JetGenerators → JetComponentSpace + | .dψ t α => derivSum (Lorentz.SL2C.toLorentzGroup M) (indexList t) fun t' => + ∑ β, spinorRep M α β • Finsupp.single (JetGenerators.dψ t' β) 1 + | .dbarψ t α => derivSum (Lorentz.SL2C.toLorentzGroup M) (indexList t) fun t' => + ∑ β, star (spinorRep M α β) • Finsupp.single (JetGenerators.dbarψ t' β) 1 + +/-- The Lorentz action on the jet component space. -/ +noncomputable def lorentzActionCS (M : SL(2,ℂ)) : + JetComponentSpace →ₗ[ℂ] JetComponentSpace := + Finsupp.lift JetComponentSpace ℂ JetGenerators (lorentzActionGenerator M) + +@[simp] +lemma lorentzActionCS_single (M : SL(2,ℂ)) (j : JetGenerators) : + lorentzActionCS M (Finsupp.single j 1) = lorentzActionGenerator M j := by + rw [lorentzActionCS, Finsupp.lift_apply, Finsupp.sum_single_index (by simp), one_smul] + +/-- The Lorentz action on the electron jet algebra: the algebra map induced by + the action on the jet coordinates. -/ +noncomputable def lorentzAction (M : SL(2,ℂ)) : JetAlgebra →ₐ[ℂ] JetAlgebra := + ExteriorAlgebra.map (lorentzActionCS M) + +@[simp] +lemma lorentzAction_ofGenerator_dψ_zero (M : SL(2,ℂ)) (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ofGenerator (.dψ 0 α)) = + ∑ β, spinorRep M α β • ofGenerator (.dψ 0 β) := by + rw [lorentzAction, ofGenerator, ExteriorAlgebra.map_apply_ι, lorentzActionCS_single, + lorentzActionGenerator, indexList_zero, derivSum_nil, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul] + rfl + +@[simp] +lemma lorentzAction_ofGenerator_dbarψ_zero (M : SL(2,ℂ)) (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ofGenerator (.dbarψ 0 α)) = + ∑ β, star (spinorRep M α β) • ofGenerator (.dbarψ 0 β) := by + rw [lorentzAction, ofGenerator, ExteriorAlgebra.map_apply_ι, lorentzActionCS_single, + lorentzActionGenerator, indexList_zero, derivSum_nil, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul] + rfl + +lemma lorentzAction_ofGenerator_dψ_singleton (M : SL(2,ℂ)) (σ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ofGenerator (.dψ {σ} α)) = + ∑ τ, ∑ β, ((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ : ℝ) • spinorRep M α β) • + ofGenerator (.dψ {τ} β) := by + rw [lorentzAction, ofGenerator, ExteriorAlgebra.map_apply_ι, lorentzActionCS_single, + lorentzActionGenerator, indexList_singleton, derivSum_cons] + rw [map_sum] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [derivSum_nil, ← algebraMap_smul ℂ (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ), + map_smul, map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, smul_smul, ← algebraMap_smul (R := ℝ) ℂ + (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ) (spinorRep M α β), smul_eq_mul, zero_add] + rfl + +lemma lorentzAction_ofGenerator_dbarψ_singleton (M : SL(2,ℂ)) (σ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ofGenerator (.dbarψ {σ} α)) = + ∑ τ, ∑ β, ((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ : ℝ) • + star (spinorRep M α β)) • ofGenerator (.dbarψ {τ} β) := by + rw [lorentzAction, ofGenerator, ExteriorAlgebra.map_apply_ι, lorentzActionCS_single, + lorentzActionGenerator, indexList_singleton, derivSum_cons] + rw [map_sum] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [derivSum_nil, ← algebraMap_smul ℂ (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ), + map_smul, map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, smul_smul, ← algebraMap_smul (R := ℝ) ℂ + (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ σ) (star (spinorRep M α β)), smul_eq_mul, + zero_add] + rfl + +/-! + +### C.5. The mass-weight scaling on the electron jet algebra + +-/ + +/-- The mass-weight scaling on the jet component space: the diagonal map + multiplying each jet coordinate by `c` to the power of its mass weight. -/ +noncomputable def massScaleCS (c : ℝ) : JetComponentSpace →ₗ[ℂ] JetComponentSpace := + Finsupp.lift JetComponentSpace ℂ JetGenerators fun j => + ((c : ℂ) ^ j.massWeight) • Finsupp.single j 1 + +/-- The mass-weight scaling on the electron jet algebra. -/ +noncomputable def massScale (c : ℝ) : JetAlgebra →ₐ[ℂ] JetAlgebra := + ExteriorAlgebra.map (massScaleCS c) + +@[simp] +lemma massScale_ofGenerator (c : ℝ) (j : JetGenerators) : + massScale c (ofGenerator j) = (c : ℂ) ^ j.massWeight • ofGenerator j := by + rw [massScale, ofGenerator, ExteriorAlgebra.map_apply_ι, massScaleCS, + Finsupp.lift_apply, Finsupp.sum_single_index (by simp), one_smul, map_smul] + +end JetAlgebra + +/-! + +### C.6. The formal total derivative on the electron jet algebra + +The total derivative extends from the jet coordinates to the whole exterior +algebra as an *even* derivation, `∂_ρ (x y) = (∂_ρ x) y + x (∂_ρ y)` with no +Koszul signs. It is constructed by lifting `ι x ↦ (ι x, ι (∂_ρ x))` to an +algebra homomorphism into the trivial square-zero extension of the jet +algebra, following +`Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.JetDeriv`. + +-/ + +/-- The jet coordinate with one further derivative in the direction `ρ`. -/ +def JetGenerators.shift (ρ : Fin 1 ⊕ Fin 3) : JetGenerators → JetGenerators + | .dψ s α => .dψ (s + {ρ}) α + | .dbarψ s α => .dbarψ (s + {ρ}) α + +namespace JetAlgebra + +/-- The total derivative on the jet component space: the shift of the + derivative multi-index. -/ +noncomputable def jetDerivCS (ρ : Fin 1 ⊕ Fin 3) : + JetComponentSpace →ₗ[ℂ] JetComponentSpace := + Finsupp.lift JetComponentSpace ℂ JetGenerators fun j => + Finsupp.single (JetGenerators.shift ρ j) 1 + +@[simp] +lemma jetDerivCS_single (ρ : Fin 1 ⊕ Fin 3) (j : JetGenerators) : + jetDerivCS ρ (Finsupp.single j 1) = + Finsupp.single (JetGenerators.shift ρ j) 1 := by + rw [jetDerivCS, Finsupp.lift_apply, Finsupp.sum_single_index (by simp), one_smul] + +/-- The generator map of the total derivative into the trivial square-zero + extension of the jet algebra: `ι x ↦ (ι x, ι (∂_ρ x))`. -/ +noncomputable def jetDerivGen (ρ : Fin 1 ⊕ Fin 3) : + JetComponentSpace →ₗ[ℂ] TrivSqZeroExt JetAlgebra JetAlgebra where + toFun x := (ExteriorAlgebra.ι ℂ x, ExteriorAlgebra.ι ℂ (jetDerivCS ρ x)) + map_add' x y := by + simp only [map_add] + rfl + map_smul' c x := by + simp only [map_smul, RingHom.id_apply] + rfl + +@[simp] +lemma jetDerivGen_fst (ρ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + (jetDerivGen ρ x).fst = ExteriorAlgebra.ι ℂ x := rfl + +@[simp] +lemma jetDerivGen_snd (ρ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + (jetDerivGen ρ x).snd = ExteriorAlgebra.ι ℂ (jetDerivCS ρ x) := rfl + +/-- The generator map squares to zero: degree-one elements of the exterior + algebra anticommute. -/ +lemma jetDerivGen_mul_self (ρ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDerivGen ρ x * jetDerivGen ρ x = 0 := by + refine TrivSqZeroExt.ext ?_ ?_ + · rw [TrivSqZeroExt.fst_mul, jetDerivGen_fst, ExteriorAlgebra.ι_sq_zero, + TrivSqZeroExt.fst_zero] + · rw [TrivSqZeroExt.snd_mul, jetDerivGen_fst, jetDerivGen_snd, TrivSqZeroExt.snd_zero, + smul_eq_mul, op_smul_eq_mul] + exact ExteriorAlgebra.ι_add_mul_swap x (jetDerivCS ρ x) + +/-- The lift of the total derivative to the trivial square-zero extension of + the jet algebra: the algebra homomorphism `x ↦ (x, ∂_ρ x)`. -/ +noncomputable def jetDerivHom (ρ : Fin 1 ⊕ Fin 3) : + JetAlgebra →ₐ[ℂ] TrivSqZeroExt JetAlgebra JetAlgebra := + ExteriorAlgebra.lift ℂ ⟨jetDerivGen ρ, jetDerivGen_mul_self ρ⟩ + +@[simp] +lemma jetDerivHom_ι (ρ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDerivHom ρ (ExteriorAlgebra.ι ℂ x) = jetDerivGen ρ x := by + rw [jetDerivHom, ExteriorAlgebra.lift_ι_apply] + +/-- The first component of the square-zero lift is the identity. -/ +@[simp] +lemma jetDerivHom_fst (ρ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + (jetDerivHom ρ x).fst = x := by + have h : (TrivSqZeroExt.fstHom ℂ JetAlgebra JetAlgebra).comp (jetDerivHom ρ) = + AlgHom.id ℂ JetAlgebra := by + refine ExteriorAlgebra.hom_ext (LinearMap.ext fun v => ?_) + simp + exact DFunLike.congr_fun h x + +/-- The formal total spacetime derivative on the electron jet algebra in the + direction `ρ`: the even derivation extending the shift + `∂_s ψ_α ↦ ∂_{s + {ρ}} ψ_α` of the jet coordinates. -/ +noncomputable def jetDeriv (ρ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℂ] JetAlgebra where + toFun x := (jetDerivHom ρ x).snd + map_add' x y := congrArg TrivSqZeroExt.snd (map_add (jetDerivHom ρ) x y) + map_smul' c x := congrArg TrivSqZeroExt.snd (map_smul (jetDerivHom ρ) c x) + +lemma jetDeriv_apply (ρ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + jetDeriv ρ x = (jetDerivHom ρ x).snd := rfl + +@[simp] +lemma jetDeriv_ι (ρ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDeriv ρ (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ (jetDerivCS ρ x) := by + rw [jetDeriv_apply, jetDerivHom_ι, jetDerivGen_snd] + +/-- The total derivative appends the derivative index to each jet + coordinate. -/ +@[simp] +lemma jetDeriv_ofGenerator (ρ : Fin 1 ⊕ Fin 3) (j : JetGenerators) : + jetDeriv ρ (ofGenerator j) = ofGenerator (JetGenerators.shift ρ j) := by + rw [ofGenerator, jetDeriv_ι, jetDerivCS_single] + rfl + +@[simp] +lemma jetDeriv_one (ρ : Fin 1 ⊕ Fin 3) : jetDeriv ρ (1 : JetAlgebra) = 0 := + congrArg TrivSqZeroExt.snd (map_one (jetDerivHom ρ)) + +/-- The total derivative is an even derivation: the Leibniz rule holds on the + electron jet algebra with no Koszul signs. -/ +lemma jetDeriv_mul (ρ : Fin 1 ⊕ Fin 3) (x y : JetAlgebra) : + jetDeriv ρ (x * y) = jetDeriv ρ x * y + x * jetDeriv ρ y := by + have h : jetDeriv ρ (x * y) = + (jetDerivHom ρ x).fst * jetDeriv ρ y + jetDeriv ρ x * (jetDerivHom ρ y).fst := + congrArg TrivSqZeroExt.snd (map_mul (jetDerivHom ρ) x y) + rw [jetDerivHom_fst, jetDerivHom_fst] at h + exact h.trans (add_comm _ _) + +end JetAlgebra + +end Electron + +/-! + +## D. The jet algebra of QED + +-/ + +/-- The jet algebra of quantum electrodynamics: the tensor product of the + complexified photon jet algebra with the electron jet algebra. + + This is a `def` rather than an `abbrev`, and its algebraic structure is fixed + by the single `Ring` and `Algebra` instances below, so that every algebraic + class projects from one root. On the bare tensor product `One`, `Mul`, + `Zero`, `Add`, `SMul` and `Module` are instead supplied by standalone + `TensorProduct.*` instances rather than as projections of the semiring; those + are definitionally the projections, but not syntactically, so a generic lemma + whose type argument is not pinned by an explicit argument (such as `one_pow`) + cannot be unified against a goal. Rooting the structure here keeps the + generic algebraic lemmas usable. -/ +def JetAlgebra : Type := (ℂ ⊗[ℝ] Photon.JetAlgebra) ⊗[ℂ] Electron.JetAlgebra + +noncomputable instance : Ring JetAlgebra := + inferInstanceAs (Ring ((ℂ ⊗[ℝ] Photon.JetAlgebra) ⊗[ℂ] Electron.JetAlgebra)) + +noncomputable instance : Algebra ℂ JetAlgebra := + inferInstanceAs (Algebra ℂ ((ℂ ⊗[ℝ] Photon.JetAlgebra) ⊗[ℂ] Electron.JetAlgebra)) + +namespace JetAlgebra + +/-! + +### D.1. Pure tensors and their arithmetic + +-/ + +/-- A pure tensor, as an element of the jet algebra. + + Writing `a ⊗ₜ[ℂ] b` builds an element of the *underlying* tensor product, + which is only definitionally an element of `JetAlgebra`. A goal mixing such + a term with the jet algebra's own operations is then not type-correct at + `instances` transparency, and no rewrite can fire on it. This constructor + keeps pure tensors typed at `JetAlgebra`. -/ +noncomputable def tmul (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + JetAlgebra := a ⊗ₜ[ℂ] b + +@[inherit_doc] scoped infixl:100 " ⊗ⱼ " => JetAlgebra.tmul + +/-- `tmul` is the pure tensor of the underlying tensor product; use this to + move between the jet algebra and lemmas stated for the tensor product. -/ +lemma tmul_eq (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + a ⊗ⱼ b = a ⊗ₜ[ℂ] b := rfl + +lemma one_eq_tmul : (1 : JetAlgebra) = (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) ⊗ⱼ 1 := rfl + +/-- Multiplication of pure tensors. `Algebra.TensorProduct.tmul_mul_tmul` does + not rewrite here, even though it is definitionally the same statement. -/ +@[simp] +lemma tmul_mul_tmul (a₁ a₂ : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b₁ b₂ : Electron.JetAlgebra) : + (a₁ ⊗ⱼ b₁) * (a₂ ⊗ⱼ b₂) = (a₁ * a₂) ⊗ⱼ (b₁ * b₂) := + Algebra.TensorProduct.tmul_mul_tmul _ _ _ _ + +@[simp] +lemma zero_tmul (b : Electron.JetAlgebra) : + (0 : ℂ ⊗[ℝ] Photon.JetAlgebra) ⊗ⱼ b = 0 := TensorProduct.zero_tmul _ b + +@[simp] +lemma tmul_zero (a : ℂ ⊗[ℝ] Photon.JetAlgebra) : + a ⊗ⱼ (0 : Electron.JetAlgebra) = 0 := TensorProduct.tmul_zero _ a + +@[simp] +lemma add_tmul (a₁ a₂ : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + (a₁ + a₂) ⊗ⱼ b = a₁ ⊗ⱼ b + a₂ ⊗ⱼ b := TensorProduct.add_tmul a₁ a₂ b + +@[simp] +lemma tmul_add (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b₁ b₂ : Electron.JetAlgebra) : + a ⊗ⱼ (b₁ + b₂) = a ⊗ⱼ b₁ + a ⊗ⱼ b₂ := TensorProduct.tmul_add a b₁ b₂ + +@[simp] +lemma sub_tmul (a₁ a₂ : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + (a₁ - a₂) ⊗ⱼ b = a₁ ⊗ⱼ b - a₂ ⊗ⱼ b := TensorProduct.sub_tmul a₁ a₂ b + +@[simp] +lemma tmul_sub (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b₁ b₂ : Electron.JetAlgebra) : + a ⊗ⱼ (b₁ - b₂) = a ⊗ⱼ b₁ - a ⊗ⱼ b₂ := TensorProduct.tmul_sub a b₁ b₂ + +@[simp] +lemma neg_tmul (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + (-a) ⊗ⱼ b = -(a ⊗ⱼ b) := TensorProduct.neg_tmul a b + +@[simp] +lemma tmul_neg (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + a ⊗ⱼ (-b) = -(a ⊗ⱼ b) := TensorProduct.tmul_neg a b + +lemma tmul_sum {ι : Type*} (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (s : Finset ι) + (f : ι → Electron.JetAlgebra) : a ⊗ⱼ (∑ i ∈ s, f i) = ∑ i ∈ s, a ⊗ⱼ f i := + TensorProduct.tmul_sum a s f + +lemma sum_tmul {ι : Type*} (s : Finset ι) (f : ι → ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : (∑ i ∈ s, f i) ⊗ⱼ b = ∑ i ∈ s, f i ⊗ⱼ b := + TensorProduct.sum_tmul s f b + +@[simp] +lemma tmul_smul (r : ℂ) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + a ⊗ⱼ (r • b) = r • (a ⊗ⱼ b) := TensorProduct.tmul_smul r a b + +@[simp] +lemma smul_tmul' (r : ℂ) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra) : + (r • a) ⊗ⱼ b = r • (a ⊗ⱼ b) := TensorProduct.smul_tmul' r a b + +/-- An `ℝ`-scalar on the photon factor is a `ℂ`-scalar of the jet algebra. -/ +lemma real_smul_tmul (r : ℝ) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : + (r • a) ⊗ⱼ b = (r : ℂ) • (a ⊗ⱼ b) := by + rw [show r • a = (r : ℂ) • a by rw [← Complex.coe_algebraMap, algebraMap_smul], + smul_tmul'] + +/-- A constant of the photon factor is a scalar of the jet algebra. -/ +lemma tmul_C_eq_smul_one (r : ℝ) : + ((1 : ℂ) ⊗ₜ[ℝ] (MvPolynomial.C r : Photon.JetAlgebra)) ⊗ⱼ + (1 : Electron.JetAlgebra) = (r : ℂ) • (1 : JetAlgebra) := by + rw [show (MvPolynomial.C r : Photon.JetAlgebra) = r • 1 by + rw [MvPolynomial.smul_eq_C_mul, mul_one], + TensorProduct.tmul_smul, + show r • ((1 : ℂ) ⊗ₜ[ℝ] (1 : Photon.JetAlgebra)) = + (r : ℂ) • (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) by + rw [← Complex.coe_algebraMap, algebraMap_smul, + Algebra.TensorProduct.one_def], + smul_tmul', ← one_eq_tmul] + +/-- Induction on the jet algebra, stated for `JetAlgebra` itself. Using + `TensorProduct.induction_on` directly leaves the zero, the sum and the pure + tensors in the goals carrying the tensor product's structure rather than the + jet algebra's, which makes those goals unrewritable. -/ +@[elab_as_elim] +lemma induction_on {motive : JetAlgebra → Prop} (x : JetAlgebra) (zero : motive 0) + (tmul : ∀ (a : ℂ ⊗[ℝ] Photon.JetAlgebra) (b : Electron.JetAlgebra), + motive (a ⊗ⱼ b)) + (add : ∀ x y : JetAlgebra, motive x → motive y → motive (x + y)) : motive x := + TensorProduct.induction_on x zero tmul add + +/-! + +### D.2. The inclusions of the two factors + +-/ + +/-- The photon factor included into the QED jet algebra. -/ +noncomputable abbrev inclA : (ℂ ⊗[ℝ] Photon.JetAlgebra) →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.includeLeft + +/-- The electron factor included into the QED jet algebra. -/ +noncomputable abbrev inclE : Electron.JetAlgebra →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.includeRight + +lemma inclA_apply (a : ℂ ⊗[ℝ] Photon.JetAlgebra) : inclA a = a ⊗ⱼ 1 := rfl + +lemma inclE_apply (b : Electron.JetAlgebra) : inclE b = 1 ⊗ⱼ b := rfl + +/-! + +### D.3. The gauge action on the QED jet algebra + +A gauge jet acts on the photon factor by the affine shift +`∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`, complexified, and on the electron factor by +the Leibniz expansion of `∂_s (ū ψ)` and `∂_s (u ψ̄)`; the action on the full +jet algebra is the tensor product of the two, an algebra map. + +-/ + +/-- The gauge action on the complexified photon jet algebra: the + complexification of the affine action `∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`. -/ +noncomputable def gaugeActionPhoton (c : Photon.JetAlgebra.GaugeJet) : + (ℂ ⊗[ℝ] Photon.JetAlgebra) →ₐ[ℂ] ℂ ⊗[ℝ] Photon.JetAlgebra := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (Photon.JetAlgebra.gaugeAction c) + +@[simp] +lemma gaugeActionPhoton_tmul (c : Photon.JetAlgebra.GaugeJet) (x : ℂ) + (p : Photon.JetAlgebra) : + gaugeActionPhoton c (x ⊗ₜ[ℝ] p) = x ⊗ₜ[ℝ] Photon.JetAlgebra.gaugeAction c p := + rfl + +/-- The gauge action on the QED jet algebra: the tensor product of the affine + action on the photon factor with the Leibniz phase rotation on the electron + factor. -/ +noncomputable def gaugeAction {e : ℝ} (g : GaugeJet e) : + JetAlgebra →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.map (gaugeActionPhoton g.χjet) + (Electron.JetAlgebra.gaugeAction g) + +lemma gaugeAction_tmul {e : ℝ} (g : GaugeJet e) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : + gaugeAction g (a ⊗ⱼ b) = + gaugeActionPhoton g.χjet a ⊗ⱼ Electron.JetAlgebra.gaugeAction g b := + rfl + +/-! + +### D.4. The Lorentz action on the QED jet algebra + +An `M : SL(2,ℂ)` acts on the photon factor through its image `Λ(M)` in the +Lorentz group, complexified, and on the electron factor through the spinor +representation; the action on the full jet algebra is the tensor product of +the two. + +-/ + +/-- The Lorentz action on the complexified photon jet algebra. -/ +noncomputable def lorentzActionPhoton (Λ : LorentzGroup 3) : + (ℂ ⊗[ℝ] Photon.JetAlgebra) →ₐ[ℂ] ℂ ⊗[ℝ] Photon.JetAlgebra := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (Photon.JetAlgebra.lorentzAction Λ) + +@[simp] +lemma lorentzActionPhoton_tmul (Λ : LorentzGroup 3) (x : ℂ) (p : Photon.JetAlgebra) : + lorentzActionPhoton Λ (x ⊗ₜ[ℝ] p) = x ⊗ₜ[ℝ] Photon.JetAlgebra.lorentzAction Λ p := + rfl + +/-- The Lorentz action on the QED jet algebra: the tensor product of the + photon action through the covering map with the electron spinor action. -/ +noncomputable def lorentzAction (M : SL(2,ℂ)) : JetAlgebra →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.map (lorentzActionPhoton (Lorentz.SL2C.toLorentzGroup M)) + (Electron.JetAlgebra.lorentzAction M) + +lemma lorentzAction_tmul (M : SL(2,ℂ)) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : + lorentzAction M (a ⊗ⱼ b) = + lorentzActionPhoton (Lorentz.SL2C.toLorentzGroup M) a ⊗ⱼ + Electron.JetAlgebra.lorentzAction M b := + rfl + +/-! TODO: Prove the composition law of the Lorentz action. Being a pullback on coordinates it -/ +/-! TODO: is a right action, `lorentzAction M ∘ lorentzAction N = lorentzAction (N * M)`; the -/ +/-! TODO: proof needs permutation-invariance and functoriality of `derivSum` over sorted lists. -/ +/-! TODO: Define an antilinear star on the QED jet algebra with `star ψ = ψ̄`, `star A = A`, and -/ +/-! TODO: prove hermiticity of the Lagrangian up to the total derivative of the kinetic term. -/ + +/-! + +### D.5. The mass-weight scaling on the QED jet algebra + +-/ + +/-- The mass-weight scaling on the complexified photon jet algebra. -/ +noncomputable def massScalePhoton (c : ℝ) : + (ℂ ⊗[ℝ] Photon.JetAlgebra) →ₐ[ℂ] ℂ ⊗[ℝ] Photon.JetAlgebra := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (Photon.JetAlgebra.massScale c) + +@[simp] +lemma massScalePhoton_tmul (c : ℝ) (x : ℂ) (p : Photon.JetAlgebra) : + massScalePhoton c (x ⊗ₜ[ℝ] p) = x ⊗ₜ[ℝ] Photon.JetAlgebra.massScale c p := + rfl + +/-- The mass-weight scaling on the QED jet algebra: the algebra map + multiplying each jet coordinate by `c` to the power of its mass weight, + i.e. `c` squared to the power of its mass dimension. -/ +noncomputable def massScale (c : ℝ) : JetAlgebra →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.map (massScalePhoton c) (Electron.JetAlgebra.massScale c) + +lemma massScale_tmul (c : ℝ) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : + massScale c (a ⊗ⱼ b) = + massScalePhoton c a ⊗ⱼ Electron.JetAlgebra.massScale c b := + rfl + +/-! + +### D.6. The formal total derivative on the QED jet algebra + +-/ + +/-- The formal total spacetime derivative on the QED jet algebra in the + direction `ρ`: the Leibniz extension of the total derivatives of the photon + and electron factors. -/ +noncomputable def jetDeriv (ρ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℂ] JetAlgebra := + TensorProduct.map (LinearMap.baseChange ℂ (Photon.JetAlgebra.jetDeriv ρ)) + LinearMap.id + + TensorProduct.map LinearMap.id (Electron.JetAlgebra.jetDeriv ρ) + +lemma jetDeriv_tmul (ρ : Fin 1 ⊕ Fin 3) (a : ℂ ⊗[ℝ] Photon.JetAlgebra) + (b : Electron.JetAlgebra) : + jetDeriv ρ (a ⊗ⱼ b) = + (LinearMap.baseChange ℂ (Photon.JetAlgebra.jetDeriv ρ) a) ⊗ⱼ b + + a ⊗ⱼ Electron.JetAlgebra.jetDeriv ρ b := rfl + +@[simp] +lemma jetDeriv_one (ρ : Fin 1 ⊕ Fin 3) : jetDeriv ρ (1 : JetAlgebra) = 0 := by + have hB : LinearMap.baseChange ℂ (Photon.JetAlgebra.jetDeriv ρ) + (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) = 0 := by + rw [show (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) = + (1 : ℂ) ⊗ₜ[ℝ] (1 : Photon.JetAlgebra) from rfl, + LinearMap.baseChange_tmul, Photon.JetAlgebra.jetDeriv_one, + TensorProduct.tmul_zero] + rw [one_eq_tmul, jetDeriv_tmul, hB, Electron.JetAlgebra.jetDeriv_one, zero_tmul, + tmul_zero, add_zero] + +/-- The total derivative is an even derivation on the QED jet algebra: the + Leibniz rule holds with no Koszul signs. -/ +lemma jetDeriv_mul (ρ : Fin 1 ⊕ Fin 3) (x y : JetAlgebra) : + jetDeriv ρ (x * y) = jetDeriv ρ x * y + x * jetDeriv ρ y := by + induction x using JetAlgebra.induction_on with + | zero => simp + | add a b ha hb => + simp only [add_mul, map_add, ha, hb] + abel + | tmul p l => + induction y using JetAlgebra.induction_on with + | zero => simp + | add a' b' ha' hb' => + simp only [mul_add, map_add, ha', hb'] + abel + | tmul p' l' => + simp only [tmul_mul_tmul, jetDeriv_tmul, add_mul, mul_add, + Photon.JetAlgebra.jetDeriv_baseChange_mul, Electron.JetAlgebra.jetDeriv_mul, + add_tmul, tmul_add, tmul_mul_tmul] + abel + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/CurrentCoupling.lean b/Physlib/Particles/QED/CurrentCoupling.lean new file mode 100644 index 000000000..6b86205a5 --- /dev/null +++ b/Physlib/Particles/QED/CurrentCoupling.lean @@ -0,0 +1,250 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Lagrangian +public import Physlib.Particles.QED.FermionStatistics +public import Physlib.Particles.QED.GaugeInvariance +public import Physlib.Particles.QED.FieldStrength +/-! +# The current coupling of quantum electrodynamics + +## i. Overview + +The interaction of QED is *minimal coupling to the Dirac current*: expanding +the covariant derivative inside the Dirac kinetic term, + +`i ψ̄ γ^μ D_μ ψ = i ψ̄ γ^μ ∂_μ ψ - e J^μ A_μ` with `J^μ = ψ̄ γ^μ ψ`. + +This is the jet-algebra counterpart of the current coupling `J^μ A_μ` of +`Physlib.Electromagnetism.Dynamics.Lagrangian`: the photon couples to matter +only through a conserved current contracted with the potential, with the +electron supplying `J^μ = ψ̄ γ^μ ψ`. + +The current is gauge invariant (`gaugeAction_diracCurrent`) — the electron +and its conjugate carry opposite charges, so the phases cancel — which is +what makes it a physically meaningful source for the photon. + +This file contains no definitions, only theorems about the fields of +`Physlib.Particles.QED.Fields` and the Lagrangian of `Physlib.Particles.QED.Lagrangian`. + +## ii. Key results + +- `JetAlgebra.diracKineticTerm_eq_free_add_current` : **minimal coupling** — + the Dirac kinetic term is the free kinetic term plus `- e J^μ A_μ`. +- `JetAlgebra.gaugeAction_diracCurrent` : the Dirac current is gauge + invariant. + +## iii. Table of contents + +- A. The minimal-coupling decomposition of the kinetic term +- B. Gauge invariance of the Dirac current + +## iv. References + +The current is defined in `Physlib.Particles.QED.Lagrangian`; the concrete +electromagnetic current coupling is +`Physlib.Electromagnetism.Dynamics.Lagrangian`. + +-/ + +@[expose] public section + +/-! TODO: Connect the QED matter content to `Physlib.QFT.QED.AnomalyCancellation`: the electron -/ +/-! TODO: spectrum is vector-like (charges `±1`), so it satisfies the gravitational and cubic -/ +/-! TODO: anomaly cancellation conditions. -/ + +namespace QED + +namespace JetAlgebra + +/-! + +## A. The minimal-coupling decomposition of the kinetic term + +The photon coordinates commute with the fermion coordinates +(`Physlib.Particles.QED.FermionStatistics`), so the interaction inside the kinetic term +reorganises into the potential times the Dirac current. + +-/ + +/-- The photon potential times the Dirac current, written through the fermion + bilinears. -/ +lemma A_mul_diracCurrent (μ : Fin 1 ⊕ Fin 3) : + A 0 μ * diracCurrent μ = + ∑ α, ∑ β, kineticGamma μ α β • (A 0 μ * (barψ 0 α * ψ 0 β)) := by + rw [diracCurrent, Finset.mul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [mul_smul_comm] + +/-- **Minimal coupling**: the Dirac kinetic term with coupling `e` is the free + Dirac kinetic term plus the current coupling `- e J^μ A_μ`. All of the + interaction of QED is the photon contracted with the Dirac current, the + jet-algebra counterpart of the current coupling of + `Physlib.Electromagnetism.Dynamics`. -/ +theorem diracKineticTerm_eq_free_add_current (e : ℝ) : + diracKineticTerm e = diracKineticTerm 0 + + (-e : ℂ) • ∑ μ, A 0 μ * diracCurrent μ := by + have hsplit : ∀ (μ : Fin 1 ⊕ Fin 3) (α β : Fin 2 ⊕ Fin 2), + barψ 0 α * covDψ e μ β = + barψ 0 α * covDψ 0 μ β + + (Complex.I * e) • (A 0 μ * (barψ 0 α * ψ 0 β)) := by + intro μ α β + rw [covDψ, covDψ, Complex.ofReal_zero, mul_zero, zero_smul, add_zero, mul_add, + mul_smul_comm, ← mul_assoc, ← A_mul_barψ_comm, mul_assoc] + rw [diracKineticTerm, diracKineticTerm, + Finset.sum_congr rfl fun μ _ => Finset.sum_congr rfl fun α _ => + Finset.sum_congr rfl fun β _ => by rw [hsplit μ α β, smul_add]] + simp only [Finset.sum_add_distrib, smul_add] + congr 1 + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => A_mul_diracCurrent μ, + Finset.smul_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [Finset.smul_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [Finset.smul_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [smul_smul, smul_smul, smul_smul] + refine congrArg (· • _) ?_ + ring_nf + rw [Complex.I_sq] + ring + +/-! + +## B. Gauge invariance of the Dirac current + +-/ + +/-- **The Dirac current is gauge invariant**: the electron and its conjugate + carry opposite charges, so the phases cancel by unitarity. This is what + makes `J^μ` a physically meaningful source for the photon. -/ +@[simp] +theorem gaugeAction_diracCurrent {e : ℝ} (g : GaugeJet e) (μ : Fin 1 ⊕ Fin 3) : + gaugeAction g (diracCurrent μ) = diracCurrent μ := by + rw [diracCurrent, map_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, + gaugeAction_mul_phase_cancel g (gaugeAction_barψ_zero g α) + (gaugeAction_ψ_zero g β)] + +/-! + +## C. Noether: conservation of the Dirac current on-shell + +-/ + +set_option maxHeartbeats 1000000 in +/-- **Noether's identity for the Dirac current**: the divergence of the + current is a combination of the Dirac-equation elements, + `i ∂_μ J^μ = ψ̄ ⬝ (Dirac eq) + (adjoint Dirac eq) ⬝ ψ`. + On solutions of the Dirac equations the current is conserved, + `∂_μ J^μ = 0` — for every coupling `e` and mass `m`: the gauge interaction + and the mass drop out of the divergence identically. -/ +theorem current_conservation (e m : ℝ) : + Complex.I • ∑ μ, jetDeriv μ (diracCurrent μ) = + ∑ α, barψ 0 α * diracEquation e m α + + ∑ β, diracAdjEquation e m β * ψ 0 β := by + have hL : ∀ μ : Fin 1 ⊕ Fin 3, jetDeriv μ (diracCurrent μ) = + (∑ α, ∑ β, kineticGamma μ α β • (barψ {μ} α * ψ 0 β)) + + ∑ α, ∑ β, kineticGamma μ α β • (barψ 0 α * ψ {μ} β) := by + intro μ + rw [diracCurrent, map_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, jetDeriv_mul, jetDeriv_barψ, jetDeriv_ψ, zero_add, smul_add] + have hT1 : ∀ α : Fin 2 ⊕ Fin 2, barψ 0 α * diracEquation e m α = + Complex.I • (∑ μ, ∑ β, kineticGamma μ α β • (barψ 0 α * ψ {μ} β)) + + (Complex.I * (Complex.I * ↑e)) • (∑ μ, ∑ β, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β))) - + (m : ℂ) • ∑ β, gammaMatrix (Sum.inl 0) α β • (barψ 0 α * ψ 0 β) := by + intro α + rw [diracEquation, mul_sub, mul_smul_comm, mul_smul_comm, Finset.mul_sum, + Finset.mul_sum] + congr 1 + · rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => Finset.mul_sum _ _ _, + show (∑ μ, ∑ β, barψ 0 α * (kineticGamma μ α β • covDψ e μ β)) = + ∑ μ, ∑ β, (kineticGamma μ α β • (barψ 0 α * ψ {μ} β) + + (Complex.I * ↑e) • (kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)))) from + Finset.sum_congr rfl fun μ _ => Finset.sum_congr rfl fun β _ => by + rw [mul_smul_comm, covDψ, mul_add, smul_add, mul_smul_comm, + ← mul_assoc, ← A_mul_barψ_comm, mul_assoc, smul_comm + (Complex.I * (e : ℂ)) (kineticGamma μ α β)]] + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => + Finset.sum_add_distrib, Finset.sum_add_distrib, smul_add] + congr 1 + rw [show (∑ μ, ∑ β, (Complex.I * (e : ℂ)) • (kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)))) = + (Complex.I * (e : ℂ)) • ∑ μ, ∑ β, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)) from by + rw [Finset.smul_sum] + exact Finset.sum_congr rfl fun μ _ => Finset.smul_sum.symm] + rw [smul_smul] + · refine congrArg _ (Finset.sum_congr rfl fun β _ => ?_) + rw [mul_smul_comm] + have hT3 : ∀ β : Fin 2 ⊕ Fin 2, diracAdjEquation e m β * ψ 0 β = + Complex.I • (∑ μ, ∑ α, kineticGamma μ α β • (barψ {μ} α * ψ 0 β)) - + (Complex.I * (Complex.I * ↑e)) • (∑ μ, ∑ α, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β))) + + (m : ℂ) • ∑ α, gammaMatrix (Sum.inl 0) α β • (barψ 0 α * ψ 0 β) := by + intro β + rw [diracAdjEquation, add_mul, smul_mul_assoc, smul_mul_assoc, Finset.sum_mul, + Finset.sum_mul] + congr 1 + · rw [show (∑ μ, (∑ α, kineticGamma μ α β • covDbarψ e μ α) * ψ 0 β) = + ∑ μ, ∑ α, (kineticGamma μ α β • (barψ {μ} α * ψ 0 β) - + (Complex.I * ↑e) • (kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)))) from + Finset.sum_congr rfl fun μ _ => by + rw [Finset.sum_mul] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [smul_mul_assoc, covDbarψ, sub_mul, smul_sub, smul_mul_assoc, + mul_assoc, smul_comm (Complex.I * (e : ℂ)) (kineticGamma μ α β)]] + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => + Finset.sum_sub_distrib _ _, Finset.sum_sub_distrib _ _, smul_sub] + congr 1 + rw [show (∑ μ, ∑ α, (Complex.I * (e : ℂ)) • (kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)))) = + (Complex.I * (e : ℂ)) • ∑ μ, ∑ α, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)) from by + rw [Finset.smul_sum] + exact Finset.sum_congr rfl fun μ _ => Finset.smul_sum.symm] + rw [smul_smul] + · refine congrArg _ (Finset.sum_congr rfl fun α _ => ?_) + rw [smul_mul_assoc] + rw [Finset.sum_congr rfl fun α (_ : α ∈ Finset.univ) => hT1 α, + Finset.sum_congr rfl fun β (_ : β ∈ Finset.univ) => hT3 β] + simp only [Finset.sum_add_distrib, Finset.sum_sub_distrib, ← Finset.smul_sum] + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => hL μ] + rw [Finset.sum_comm (f := fun α μ => ∑ β, kineticGamma μ α β • + (barψ 0 α * ψ {μ} β)), + Finset.sum_comm (f := fun β μ => ∑ α, kineticGamma μ α β • + (barψ {μ} α * ψ 0 β)), + Finset.sum_comm (f := fun α μ => ∑ β, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β))), + Finset.sum_comm (f := fun β μ => ∑ α, kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β)))] + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => + (Finset.sum_comm (f := fun β α => kineticGamma μ α β • + (A 0 μ * (barψ 0 α * ψ 0 β))))] + rw [Finset.sum_congr rfl fun μ (_ : μ ∈ Finset.univ) => + (Finset.sum_comm (f := fun β α => kineticGamma μ α β • + (barψ {μ} α * ψ 0 β)))] + rw [Finset.sum_comm (f := fun β α => gammaMatrix (Sum.inl 0) α β • + (barψ 0 α * ψ 0 β))] + simp only [smul_add, Finset.smul_sum] + rw [Finset.sum_add_distrib] + abel + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/Evaluation.lean b/Physlib/Particles/QED/Evaluation.lean new file mode 100644 index 000000000..259e728a9 --- /dev/null +++ b/Physlib/Particles/QED/Evaluation.lean @@ -0,0 +1,449 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Fields +public import Physlib.Particles.QED.FieldStrength +public import Physlib.Particles.QED.LorentzInvariance +public import Physlib.Electromagnetism.Kinematics.ElectricField +public import Physlib.Electromagnetism.Kinematics.MagneticField +public import Physlib.Electromagnetism.Dynamics.IsExtrema +/-! +# Evaluation of the photon jet algebra on a potential + +## i. Overview + +The theorems tying the formal photon jet algebra of QED to the honest +electromagnetism of `Physlib.Electromagnetism`, through the evaluation map +`Photon.JetAlgebra.evalPotential` of `Physlib.Particles.QED.Basic`: + +* evaluated on any differentiable potential, the formal field strength is the + field strength of the potential with both indices lowered; +* evaluated on any differentiable potential, the formal Maxwell term + `F_{μν} F^{μν}` is `-4 μ₀` times `ElectromagneticPotential.kineticTerm`; +* the evaluation is compatible with concrete gauge transformations + `A ↦ A + ∂χ`, matching the formal gauge invariance of + `Physlib.Particles.QED.GaugeInvariance` on the concrete side. + +Only the photon sector evaluates: fermionic jet coordinates would have to be +evaluated on anticommuting (Grassmann-valued) fields, which have no +realisation as honest functions on spacetime. + +This file contains no definitions, only theorems. + +## ii. Key results + +- `Photon.JetAlgebra.evalPotential_fieldStrength_zero` : the formal field + strength evaluates to the field strength. +- `Photon.JetAlgebra.evalPotential_maxwellTerm` : **the formal Maxwell term + is the Maxwell Lagrangian**. +- `Photon.JetAlgebra.electricField_eq_evalPotential_fieldStrength`, + `Photon.JetAlgebra.magneticField_eq_evalPotential_fieldStrength` : the + time–space and space–space components of the evaluated formal field + strength are the electric and magnetic fields. +- `Photon.JetAlgebra.evalPotential_neg_quarter_maxwellTerm` : the Maxwell + part of the QED Lagrangian is `μ₀` times the electromagnetic kinetic term. +- `Photon.JetAlgebra.evalPotential_fieldStrength_gaugeTransform`, + `Photon.JetAlgebra.evalPotential_maxwellTerm_gaugeTransform` : + compatibility with concrete gauge transformations. +- `Photon.JetAlgebra.evalPotential_maxwell_homogeneous` : **the homogeneous + Maxwell equations**, as the evaluation of the formal Bianchi identity. +- `Photon.JetAlgebra.evalPotential_fieldStrength_lorentzAction` : + compatibility of the formal and concrete Lorentz actions. + +## iii. Table of contents + +- A. Evaluation of the field strength +- B. The Maxwell term is the Maxwell Lagrangian +- B'. The electric and magnetic fields from the jet algebra +- B''. The Maxwell part of the QED Lagrangian +- D. First-order jets and the homogeneous Maxwell equations +- E. Compatibility with concrete Lorentz transformations +- C. Compatibility with concrete gauge transformations + +## iv. References + +The evaluation map is defined in `Physlib.Particles.QED.Basic`; the concrete side is +`Physlib/Electromagnetism/Kinematics/GaugeTransformation.lean` and +`Physlib/Electromagnetism/Dynamics/KineticTerm.lean`. + +-/ + +@[expose] public section + +namespace QED + +open Electromagnetism SpaceTime minkowskiMatrix ContDiff + +attribute [-simp] Fintype.sum_sum_type + +namespace Photon + +namespace JetAlgebra + +/-! + +## A. Evaluation of the field strength + +-/ + +/-- The derivative of a covariant component. Differentiability is needed to move + the constant `η_{νν}` through the derivative. -/ +lemma deriv_coPotential (A : ElectromagneticPotential 3) (hA : Differentiable ℝ A) + (μ ν : Fin 1 ⊕ Fin 3) (x : SpaceTime 3) : + ∂_ μ (coPotential A ν) x = η ν ν * ∂_ μ A x ν := by + have hd : Differentiable ℝ (fun y => A y ν) := (SpaceTime.differentiable_vector _).mpr hA ν + rw [SpaceTime.deriv_apply_eq μ ν _ hA x] + show fderiv ℝ (fun y => η ν ν * A y ν) x (Lorentz.Vector.basis μ) = _ + rw [fderiv_const_mul (hd x)] + simp + +lemma evalPotential_fieldStrength_zero_apply (A : ElectromagneticPotential 3) + (hA : Differentiable ℝ A) (μ ν : Fin 1 ⊕ Fin 3) (x : SpaceTime 3) : + evalPotential A (fieldStrength 0 μ ν) x = η ν ν * ∂_ μ A x ν - η μ μ * ∂_ ν A x μ := by + rw [fieldStrength, map_sub] + simp only [zero_add, evalPotential_coord, derivMultiset_singleton, Pi.sub_apply] + rw [deriv_coPotential A hA μ ν x, deriv_coPotential A hA ν μ x] + +/-- The formal field strength evaluates to the field strength of the potential + with both indices lowered, `F_{μν} = η_{μμ} η_{νν} F^{μν}`. -/ +theorem evalPotential_fieldStrength_zero (A : ElectromagneticPotential 3) + (hA : Differentiable ℝ A) (μ ν : Fin 1 ⊕ Fin 3) (x : SpaceTime 3) : + evalPotential A (fieldStrength 0 μ ν) x = + η μ μ * η ν ν * A.fieldStrengthMatrix x (μ, ν) := by + rw [evalPotential_fieldStrength_zero_apply A hA μ ν x, + ElectromagneticPotential.toFieldStrength_basis_repr_apply_eq_single (μν := (μ, ν))] + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag μ) with h1 | h1 <;> + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag ν) with h2 | h2 <;> + rw [h1, h2] <;> ring + +/-! + +## B. The Maxwell term is the Maxwell Lagrangian + +-/ + +/-- **The formal Maxwell term is the Maxwell Lagrangian.** Evaluated on any + differentiable electromagnetic potential, the gauge-invariant jet polynomial + `F_{μν} F^{μν}` is `-4 μ₀` times the kinetic term + `- 1/(4 μ₀) F_{μν} F^{μν}` of `Physlib.Electromagnetism`. -/ +theorem evalPotential_maxwellTerm (𝓕 : FreeSpace) (A : ElectromagneticPotential 3) + (hA : Differentiable ℝ A) (x : SpaceTime 3) : + evalPotential A maxwellTerm x = -(4 * 𝓕.μ₀) * A.kineticTerm 𝓕 x := by + rw [ElectromagneticPotential.kineticTerm_eq_sum_potential, maxwellTerm, map_sum] + simp only [Finset.sum_apply, map_sum, map_smul, Pi.smul_apply, smul_eq_mul, map_mul, + Pi.mul_apply] + simp only [evalPotential_fieldStrength_zero_apply A hA] + /- Both sides are now explicit double sums in `∂_ μ A x ν`. -/ + have key : ∀ μ ν : Fin 1 ⊕ Fin 3, + η μ μ * η ν ν * ((η ν ν * ∂_ μ A x ν - η μ μ * ∂_ ν A x μ) * + (η ν ν * ∂_ μ A x ν - η μ μ * ∂_ ν A x μ)) = + (η μ μ * η ν ν * (∂_ μ A x ν) ^ 2 - ∂_ μ A x ν * ∂_ ν A x μ) + + (η ν ν * η μ μ * (∂_ ν A x μ) ^ 2 - ∂_ ν A x μ * ∂_ μ A x ν) := by + intro μ ν + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag μ) with h1 | h1 <;> + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag ν) with h2 | h2 <;> + rw [h1, h2] <;> ring + rw [Finset.sum_congr rfl fun μ _ => Finset.sum_congr rfl fun ν _ => key μ ν] + simp only [Finset.sum_add_distrib] + rw [Finset.sum_comm (s := Finset.univ) (t := Finset.univ) + (f := fun μ ν : Fin 1 ⊕ Fin 3 => + η ν ν * η μ μ * (∂_ ν A x μ) ^ 2 - ∂_ ν A x μ * ∂_ μ A x ν)] + have hμ₀ : 𝓕.μ₀ ≠ 0 := ne_of_gt 𝓕.μ₀_pos + field_simp + ring + +/-! + +## B'. The electric and magnetic fields from the jet algebra + +Splitting spacetime into time and space through `toTimeAndSpace`, the +time–space components of the evaluated formal field strength are the electric +field and the space–space components the magnetic field of +`Physlib.Electromagnetism`. + +-/ + +/-- The electric field is (the speed of light times) the evaluated time–space + components of the formal field strength: `E_i = c ∂_0 A_i - c ∂_i A_0` + with lowered indices. -/ +theorem electricField_eq_evalPotential_fieldStrength (c : SpeedOfLight) + (A : ElectromagneticPotential 3) (hA : Differentiable ℝ A) (t : Time) + (x : Space) (i : Fin 3) : + A.electricField c t x i = + c * evalPotential A (fieldStrength 0 (Sum.inl 0) (Sum.inr i)) + ((toTimeAndSpace c).symm (t, x)) := by + rw [evalPotential_fieldStrength_zero A hA, + ElectromagneticPotential.electricField_eq_fieldStrengthMatrix A t x i hA] + simp only [inl_0_inl_0, inr_i_inr_i, one_mul, neg_mul] + ring + +/-- The magnetic field is the evaluated space–space components of the formal + field strength, `B_i = - F_{(i+1)(i+2)}` with lowered indices. -/ +theorem magneticField_eq_evalPotential_fieldStrength (c : SpeedOfLight) + (A : ElectromagneticPotential 3) (hA : Differentiable ℝ A) (t : Time) + (x : Space) (i : Fin 3) : + A.magneticField c t x i = + - evalPotential A (fieldStrength 0 (Sum.inr (i + 1)) (Sum.inr (i + 2))) + ((toTimeAndSpace c).symm (t, x)) := by + rw [evalPotential_fieldStrength_zero A hA, + ElectromagneticPotential.magneticField_coord_eq_fieldStrengthMatrix A t x hA] + simp only [inr_i_inr_i, neg_mul, one_mul, neg_neg] + +/-! + +## B''. The Maxwell part of the QED Lagrangian + +-/ + +/-- The Maxwell part `- 1/4 F_{μν} F^{μν}` of the QED Lagrangian evaluates to + `μ₀` times the electromagnetic kinetic term of + `Physlib.Electromagnetism.Dynamics`: the two Lagrangians agree up to the + choice of units absorbed into the field normalisation. -/ +theorem evalPotential_neg_quarter_maxwellTerm (𝓕 : FreeSpace) + (A : ElectromagneticPotential 3) (hA : Differentiable ℝ A) (x : SpaceTime 3) : + evalPotential A ((-(1 : ℝ)/4) • maxwellTerm) x = 𝓕.μ₀ * A.kineticTerm 𝓕 x := by + rw [map_smul] + have h := evalPotential_maxwellTerm 𝓕 A hA x + rw [Pi.smul_apply, smul_eq_mul, h] + ring + +/-! + +## D. First-order jets and the homogeneous Maxwell equations + +Evaluation intertwines the first-order jet of the field strength with the +honest spacetime derivative — for a `C²` potential the sorted iterated +derivative is symmetric by Clairaut's theorem — and hence the formal Bianchi +identity of `Physlib.Particles.QED.FieldStrength` evaluates to **the homogeneous +Maxwell equations** in covariant form. + +-/ + +lemma contDiff_coPotential {A : ElectromagneticPotential 3} (hA : ContDiff ℝ 2 A) + (ν : Fin 1 ⊕ Fin 3) : ContDiff ℝ 2 (coPotential A ν) := by + have h : ContDiff ℝ 2 fun x => A x ν := (SpaceTime.contDiff_vector _).mpr hA ν + exact contDiff_const.mul h + +/-- The iterated derivative along a pair of directions, in either order: for a + `C²` function the canonical sorted order is immaterial by Clairaut's + theorem. -/ +lemma derivMultiset_pair (a b : Fin 1 ⊕ Fin 3) (f : SpaceTime 3 → ℝ) + (hf : ContDiff ℝ 2 f) : + derivMultiset {a, b} f = ∂_ a (∂_ b f) := by + have key : ∀ u v : Fin 1 ⊕ Fin 3, + finSumFinEquiv (m := 1) (n := 3) u ≤ finSumFinEquiv (m := 1) (n := 3) v → + derivMultiset {u, v} f = ∂_ u (∂_ v f) := by + intro u v huv + have hsort : ((finSumFinEquiv (m := 1) (n := 3) u ::ₘ + {finSumFinEquiv (m := 1) (n := 3) v}).sort fun a b => a ≤ b) = + [finSumFinEquiv (m := 1) (n := 3) u, finSumFinEquiv (m := 1) (n := 3) v] := by + rw [Multiset.sort_cons] + · rw [Multiset.sort_singleton] + · intro c hc + rw [Multiset.mem_singleton] at hc + rw [hc] + exact huv + rw [derivMultiset, show ({u, v} : Multiset (Fin 1 ⊕ Fin 3)).map + (finSumFinEquiv (m := 1) (n := 3)) = + finSumFinEquiv (m := 1) (n := 3) u ::ₘ {finSumFinEquiv (m := 1) (n := 3) v} from by + simp, hsort] + simp + rcases le_total (finSumFinEquiv (m := 1) (n := 3) a) (finSumFinEquiv (m := 1) (n := 3) b) + with h | h + · exact key a b h + · rw [show ({a, b} : Multiset (Fin 1 ⊕ Fin 3)) = {b, a} from Multiset.pair_comm a b, + key b a h, SpaceTime.deriv_commute b a f hf] + +lemma deriv_sub_eq {f g : SpaceTime 3 → ℝ} (lam : Fin 1 ⊕ Fin 3) + (hf : Differentiable ℝ f) (hg : Differentiable ℝ g) : + ∂_ lam (f - g) = ∂_ lam f - ∂_ lam g := by + ext x + rw [Pi.sub_apply, SpaceTime.deriv_eq, SpaceTime.deriv_eq, SpaceTime.deriv_eq, + fderiv_sub (hf x) (hg x)] + simp + +/-- Evaluation intertwines the first-order jet with the spacetime derivative: + the evaluated `∂_lam F_{μν}` is the derivative of the evaluated `F_{μν}`. -/ +theorem evalPotential_fieldStrength_singleton (A : ElectromagneticPotential 3) + (hA : ContDiff ℝ 2 A) (lam μ ν : Fin 1 ⊕ Fin 3) : + evalPotential A (fieldStrength {lam} μ ν) = + ∂_ lam (evalPotential A (fieldStrength 0 μ ν)) := by + have hsub : evalPotential A (fieldStrength 0 μ ν) = + ∂_ μ (coPotential A ν) - ∂_ ν (coPotential A μ) := by + rw [fieldStrength, map_sub] + simp only [zero_add, evalPotential_coord, derivMultiset_singleton] + rw [hsub, deriv_sub_eq lam + (SpaceTime.differentiable_deriv μ _ (contDiff_coPotential hA ν)) + (SpaceTime.differentiable_deriv ν _ (contDiff_coPotential hA μ)), + fieldStrength, map_sub] + simp only [evalPotential_coord, Multiset.singleton_add] + simp only [← Multiset.insert_eq_cons] + rw [derivMultiset_pair lam μ _ (contDiff_coPotential hA ν), + derivMultiset_pair lam ν _ (contDiff_coPotential hA μ)] + +/-- **The homogeneous Maxwell equations** in covariant form, + `∂_lam F_{μν} + ∂_μ F_{ν lam} + ∂_ν F_{lam μ} = 0`, as the evaluation of the + formal Bianchi identity of `Physlib.Particles.QED.FieldStrength`: Faraday's law and + the absence of magnetic monopoles are its time–space–space and + space–space–space components. -/ +theorem evalPotential_maxwell_homogeneous (A : ElectromagneticPotential 3) + (hA : ContDiff ℝ 2 A) (lam μ ν : Fin 1 ⊕ Fin 3) : + ∂_ lam (evalPotential A (fieldStrength 0 μ ν)) + + ∂_ μ (evalPotential A (fieldStrength 0 ν lam)) + + ∂_ ν (evalPotential A (fieldStrength 0 lam μ)) = 0 := by + rw [← evalPotential_fieldStrength_singleton A hA lam μ ν, + ← evalPotential_fieldStrength_singleton A hA μ ν lam, + ← evalPotential_fieldStrength_singleton A hA ν lam μ, ← map_add, ← map_add, + show fieldStrength {lam} μ ν + fieldStrength {μ} ν lam + + fieldStrength {ν} lam μ = 0 from by + simpa using fieldStrength_bianchi 0 lam μ ν, + map_zero] + +/-! + +## D'. The inhomogeneous Maxwell equations and the action principle + +The concrete side (`Physlib.Electromagnetism.Dynamics.IsExtrema`) proves +variationally that a potential extremises the electromagnetic action exactly +when `∂_μ F^{μν} = μ₀ J^ν`. The left-hand side is the evaluation of the +formal Maxwell operator of `Physlib.Particles.QED.Fields`, so the action +principle can be read entirely through the jet algebra. + +-/ + +lemma deriv_const_mul_apply (c : ℝ) {f : SpaceTime 3 → ℝ} (ρ : Fin 1 ⊕ Fin 3) + (hf : Differentiable ℝ f) (x : SpaceTime 3) : + ∂_ ρ (fun y => c * f y) x = c * ∂_ ρ f x := by + rw [SpaceTime.deriv_eq, SpaceTime.deriv_eq, fderiv_const_mul (hf x)] + simp + +/-- **The action principle through the jet algebra**: an electromagnetic + potential extremises the Maxwell action with source `J` exactly when the + evaluated formal Maxwell operator equals `μ₀ J` — the inhomogeneous Maxwell + equations `∂_μ F^{μν} = μ₀ J^ν`. -/ +theorem isExtrema_iff_evalPotential_maxwellOperator (𝓕 : FreeSpace) + (A : ElectromagneticPotential 3) (hA : ContDiff ℝ ∞ A) + (J : LorentzCurrentDensity 3) (hJ : ContDiff ℝ ∞ J) : + ElectromagneticPotential.IsExtrema 𝓕 A J ↔ + ∀ x ν, evalPotential A (maxwellOperator ν) x = 𝓕.μ₀ * J x ν := by + have h2 : ContDiff ℝ 2 A := hA.of_le ENat.LEInfty.out + have hdiffF : ∀ μ' ν' : Fin 1 ⊕ Fin 3, + Differentiable ℝ (evalPotential A (fieldStrength 0 μ' ν')) := by + intro μ' ν' + rw [show evalPotential A (fieldStrength 0 μ' ν') = + ∂_ μ' (coPotential A ν') - ∂_ ν' (coPotential A μ') from by + rw [fieldStrength, map_sub] + simp only [zero_add, evalPotential_coord, derivMultiset_singleton]] + exact (SpaceTime.differentiable_deriv _ _ (contDiff_coPotential h2 ν')).sub + (SpaceTime.differentiable_deriv _ _ (contDiff_coPotential h2 μ')) + rw [ElectromagneticPotential.isExtrema_iff_fieldStrengthMatrix A hA J hJ] + refine forall_congr' fun x => forall_congr' fun ν => Iff.of_eq ?_ + refine congrArg (· = 𝓕.μ₀ * J x ν) ?_ + have hFmat : ∀ μ' : Fin 1 ⊕ Fin 3, (fun y => A.fieldStrengthMatrix y (μ', ν)) = + fun y => (η μ' μ' * η ν ν) * evalPotential A (fieldStrength 0 μ' ν) y := by + intro μ' + funext y + rw [evalPotential_fieldStrength_zero A (h2.differentiable two_ne_zero) μ' ν y] + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag μ') with + h1 | h1 <;> + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag ν) with + h2' | h2' <;> + rw [h1, h2'] <;> ring + calc ∑ μ, ∂_ μ (A.fieldStrengthMatrix · (μ, ν)) x + = ∑ μ, (η μ μ * η ν ν) * ∂_ μ (evalPotential A (fieldStrength 0 μ ν)) x := by + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [show (fun y => A.fieldStrengthMatrix y (μ, ν)) = + fun y => (η μ μ * η ν ν) * evalPotential A (fieldStrength 0 μ ν) y from + hFmat μ, deriv_const_mul_apply _ _ (hdiffF μ ν)] + _ = evalPotential A (maxwellOperator ν) x := by + rw [maxwellOperator, map_sum, Finset.sum_apply] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_smul, Pi.smul_apply, smul_eq_mul, + evalPotential_fieldStrength_singleton A h2 μ μ ν] + +/-! + +## E. Compatibility with concrete Lorentz transformations + +The formal Lorentz action of `Physlib.Particles.QED.Basic` is matched by the concrete +action `(Λ • A) x = Λ • A (Λ⁻¹ • x)` of `Physlib.Electromagnetism`: +evaluating the field strength on the transformed potential is evaluating the +Lorentz-transformed jet on the original potential at the transformed point. + +-/ + +/-- **Compatibility of the formal and concrete Lorentz actions**: the + evaluation of the field strength on `Λ • A` at `x` is the evaluation of its + formal Lorentz transform on `A` at `Λ⁻¹ • x`, matching the equivariance + `Physlib.Electromagnetism.Kinematics.FieldStrength.toFieldStrength_equivariant` + on the concrete side. -/ +theorem evalPotential_fieldStrength_lorentzAction (Λ : LorentzGroup 3) + (A : ElectromagneticPotential 3) (hA : Differentiable ℝ A) + (μ ν : Fin 1 ⊕ Fin 3) (x : SpaceTime 3) : + evalPotential (Λ • A) (fieldStrength 0 μ ν) x = + evalPotential A (lorentzAction Λ (fieldStrength 0 μ ν)) (Λ⁻¹ • x) := by + have hinv : ∀ a μ' : Fin 1 ⊕ Fin 3, (Λ⁻¹).1 a μ' = η a a * Λ.1 μ' a * η μ' μ' := by + intro a μ' + rw [LorentzGroup.inv_eq_dual] + exact minkowskiMatrix.dual_apply _ a μ' + have hΛA : Differentiable ℝ (Λ • A) := + ElectromagneticPotential.differentiable_action Λ A hA + rw [evalPotential_fieldStrength_zero _ hΛA μ ν x, + ElectromagneticPotential.fieldStrengthMatrix_equivariant A Λ hA, + lorentzAction_fieldStrength_zero] + simp only [map_sum, map_smul, Finset.sum_apply, Pi.smul_apply, smul_eq_mul] + simp only [evalPotential_fieldStrength_zero A hA] + simp only [Finset.mul_sum] + refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => ?_ + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag a) with h1 | h1 <;> + rcases mul_self_eq_one_iff.mp (minkowskiMatrix.η_apply_mul_η_apply_diag b) with h2 | h2 <;> + rw [hinv a μ, hinv b ν, h1, h2] <;> ring + +/-! + +## C. Compatibility with concrete gauge transformations + +The formal gauge invariance of `Physlib.Particles.QED.GaugeInvariance` is matched on +the concrete side: the evaluation of the field strength, and hence of the +Maxwell term, is unchanged when the potential is replaced by `A + ∂χ`. + +-/ + +lemma differentiable_gaugeTransform {A : ElectromagneticPotential 3} {χ : SpaceTime 3 → ℝ} + (hA : Differentiable ℝ A) (hχ : ContDiff ℝ 2 χ) : + Differentiable ℝ (ElectromagneticPotential.gaugeTransform χ A) := + hA.add (ElectromagneticPotential.differentiable_ofGradient hχ) + +/-- The evaluated field strength is invariant under the concrete gauge + transformation `A ↦ A + ∂χ`, matching the formal gauge invariance + `Physlib.Particles.QED.GaugeInvariance.Photon.JetAlgebra.gaugeAction_fieldStrength`. -/ +theorem evalPotential_fieldStrength_gaugeTransform (A : ElectromagneticPotential 3) + (χ : SpaceTime 3 → ℝ) (hA : Differentiable ℝ A) (hχ : ContDiff ℝ 2 χ) + (μ ν : Fin 1 ⊕ Fin 3) (x : SpaceTime 3) : + evalPotential (ElectromagneticPotential.gaugeTransform χ A) (fieldStrength 0 μ ν) x = + evalPotential A (fieldStrength 0 μ ν) x := by + rw [evalPotential_fieldStrength_zero _ (differentiable_gaugeTransform hA hχ), + evalPotential_fieldStrength_zero A hA, + ElectromagneticPotential.fieldStrengthMatrix_gaugeTransform A χ hA hχ] + +/-- The Maxwell Lagrangian is gauge invariant, as read off from the jet algebra. -/ +theorem evalPotential_maxwellTerm_gaugeTransform (A : ElectromagneticPotential 3) + (χ : SpaceTime 3 → ℝ) (hA : Differentiable ℝ A) (hχ : ContDiff ℝ 2 χ) + (x : SpaceTime 3) : + evalPotential (ElectromagneticPotential.gaugeTransform χ A) maxwellTerm x = + evalPotential A maxwellTerm x := by + rw [maxwellTerm, map_sum, map_sum] + simp only [Finset.sum_apply, map_sum, map_smul, Pi.smul_apply, smul_eq_mul, map_mul, + Pi.mul_apply] + refine Finset.sum_congr rfl fun μ _ => Finset.sum_congr rfl fun ν _ => ?_ + rw [evalPotential_fieldStrength_gaugeTransform A χ hA hχ] + +end JetAlgebra + +end Photon + +end QED diff --git a/Physlib/Particles/QED/FermionStatistics.lean b/Physlib/Particles/QED/FermionStatistics.lean new file mode 100644 index 000000000..027692826 --- /dev/null +++ b/Physlib/Particles/QED/FermionStatistics.lean @@ -0,0 +1,146 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Fields +/-! +# Spin-statistics of the QED fields + +## i. Overview + +The statistics of the fields of QED, as encoded in the QED jet algebra: the +electron jet coordinates anticommute among themselves and square to zero +(fermionic statistics), while the photon jet coordinates commute with +everything (bosonic statistics). + +This file contains no definitions, only theorems about the fields of +`Physlib.Particles.QED.Fields`. + +## ii. Key results + +- `Electron.JetAlgebra.ofGenerator_mul_self`, + `Electron.JetAlgebra.ofGenerator_anticommute` : fermionic statistics of the + electron jet coordinates. +- `JetAlgebra.ψ_mul_ψ_anticomm`, `JetAlgebra.ψ_mul_barψ_anticomm`, + `JetAlgebra.barψ_mul_barψ_anticomm` : the electron coordinates anticommute + in the QED jet algebra. +- `JetAlgebra.ψ_mul_self`, `JetAlgebra.barψ_mul_self` : Pauli exclusion for + the jet coordinates. +- `JetAlgebra.A_mul_A_comm`, `JetAlgebra.A_mul_ψ_comm`, + `JetAlgebra.A_mul_barψ_comm` : the photon coordinates are bosonic. + +## iii. Table of contents + +- A. Fermionic statistics of the electron jet coordinates +- B. Fermionic statistics in the QED jet algebra +- C. Bosonic statistics of the photon jet coordinates + +## iv. References + +The fields are defined in `Physlib.Particles.QED.Fields`. + +-/ + +@[expose] public section + +namespace QED + +/-! + +## A. Fermionic statistics of the electron jet coordinates + +-/ + +namespace Electron + +namespace JetAlgebra + +@[simp] +lemma ofGenerator_mul_self (j : JetGenerators) : + ofGenerator j * ofGenerator j = 0 := + ExteriorAlgebra.ι_sq_zero _ + +/-- The jet coordinates of the electron anticommute: the electron is a + fermion. -/ +theorem ofGenerator_anticommute (i j : JetGenerators) : + ofGenerator i * ofGenerator j = -(ofGenerator j * ofGenerator i) := by + have h := ExteriorAlgebra.ι_sq_zero (R := ℂ) (M := JetComponentSpace) + (Finsupp.single i 1 + Finsupp.single j 1) + rw [map_add, add_mul, mul_add, mul_add, ExteriorAlgebra.ι_sq_zero, + ExteriorAlgebra.ι_sq_zero, zero_add, add_zero] at h + exact eq_neg_of_add_eq_zero_left h + +end JetAlgebra + +end Electron + +namespace JetAlgebra + +/-! + +## B. Fermionic statistics in the QED jet algebra + +-/ + +/-- The electron jet coordinates anticommute. -/ +theorem ψ_mul_ψ_anticomm (s t : Multiset (Fin 1 ⊕ Fin 3)) (α β : Fin 2 ⊕ Fin 2) : + ψ s α * ψ t β = -(ψ t β * ψ s α) := by + simp only [ψ, tmul_mul_tmul, one_mul] + rw [Electron.JetAlgebra.ofGenerator_anticommute, tmul_neg] + +/-- The electron and conjugate-electron jet coordinates anticommute. -/ +theorem ψ_mul_barψ_anticomm (s t : Multiset (Fin 1 ⊕ Fin 3)) (α β : Fin 2 ⊕ Fin 2) : + ψ s α * barψ t β = -(barψ t β * ψ s α) := by + simp only [ψ, barψ, tmul_mul_tmul, one_mul] + rw [Electron.JetAlgebra.ofGenerator_anticommute, tmul_neg] + +/-- The conjugate-electron jet coordinates anticommute. -/ +theorem barψ_mul_barψ_anticomm (s t : Multiset (Fin 1 ⊕ Fin 3)) (α β : Fin 2 ⊕ Fin 2) : + barψ s α * barψ t β = -(barψ t β * barψ s α) := by + simp only [barψ, tmul_mul_tmul, one_mul] + rw [Electron.JetAlgebra.ofGenerator_anticommute, tmul_neg] + +/-- Pauli exclusion: an electron jet coordinate squares to zero. -/ +@[simp] +theorem ψ_mul_self (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + ψ s α * ψ s α = 0 := by + simp [ψ] + +/-- Pauli exclusion: a conjugate electron jet coordinate squares to zero. -/ +@[simp] +theorem barψ_mul_self (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + barψ s α * barψ s α = 0 := by + simp [barψ] + +/-! + +## C. Bosonic statistics of the photon jet coordinates + +-/ + +/-- The photon jet coordinates commute among themselves: the photon is a + boson. -/ +theorem A_mul_A_comm (s t : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + A s μ * A t ν = A t ν * A s μ := by + simp only [A, tmul_mul_tmul, mul_one] + rw [mul_comm] + +/-- The photon jet coordinates commute with the electron jet coordinates. -/ +theorem A_mul_ψ_comm (s t : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + A s μ * ψ t α = ψ t α * A s μ := by + simp only [A, ψ, tmul_mul_tmul, one_mul, mul_one] + +/-- The photon jet coordinates commute with the conjugate electron jet + coordinates. -/ +theorem A_mul_barψ_comm (s t : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + A s μ * barψ t α = barψ t α * A s μ := by + simp only [A, barψ, tmul_mul_tmul, one_mul, mul_one] + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/FieldStrength.lean b/Physlib/Particles/QED/FieldStrength.lean new file mode 100644 index 000000000..0ddd25e4f --- /dev/null +++ b/Physlib/Particles/QED/FieldStrength.lean @@ -0,0 +1,202 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Fields +/-! +# Properties of the field strength + +## i. Overview + +The structural theorems about the electromagnetic field strength in the jet +algebras of QED: antisymmetry, the expression of the field strength through +the potential coordinates, and the **Bianchi identity** + +`∂_λ F_{μν} + ∂_μ F_{νλ} + ∂_ν F_{λμ} = 0`, + +the homogeneous half of Maxwell's equations. In the jet algebra the Bianchi +identity is exact and purely combinatorial: each term is a difference of +second-derivative coordinates, and the six coordinates cancel in pairs because +multiset addition is commutative — Clairaut's theorem is built into the +indexing. + +This file contains no definitions, only theorems about the fields of +`Physlib.Particles.QED.Fields`. + +## ii. Key results + +- `Photon.JetAlgebra.fieldStrength_antisymm`, + `JetAlgebra.fieldStrength_antisymm` : antisymmetry of the field strength. +- `JetAlgebra.fieldStrength_eq_sub` : the field strength through the + potential coordinates, `F_{μν} = ∂_μ A_ν - ∂_ν A_μ`. +- `Photon.JetAlgebra.fieldStrength_bianchi`, + `JetAlgebra.fieldStrength_bianchi` : **the Bianchi identity**. + +## iii. Table of contents + +- A. The field strength in the photon jet algebra + - A.1. Antisymmetry + - A.2. The Bianchi identity +- B. The field strength in the QED jet algebra + +## iv. References + +The fields are defined in `Physlib.Particles.QED.Fields`. The inhomogeneous half of +Maxwell's equations is dynamical (it needs the variation of the Lagrangian) +and is not part of the jet-algebra kinematics. + +-/ + +@[expose] public section + +namespace QED + +open TensorProduct + +namespace Photon + +namespace JetAlgebra + +/-! + +## A. The field strength in the photon jet algebra + +### A.1. Antisymmetry + +-/ + +theorem fieldStrength_antisymm (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength s μ ν = -fieldStrength s ν μ := by + simp [fieldStrength] + +@[simp] +theorem fieldStrength_self (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + fieldStrength s μ μ = 0 := by + simp [fieldStrength] + +/-! + +### A.2. The Bianchi identity + +Each field strength is a difference of two second-derivative coordinates; the +cyclic sum produces six coordinates which cancel in pairs, because the +multisets `s + {μ} + {ν}` and `s + {ν} + {μ}` are equal. + +-/ + +/-- **The Bianchi identity** `∂_lam F_{μν} + ∂_μ F_{ν lam} + ∂_ν F_{lam μ} = 0` + in the photon jet algebra: the homogeneous Maxwell equations hold exactly, + for every derivative order `s`. -/ +theorem fieldStrength_bianchi (s : Multiset (Fin 1 ⊕ Fin 3)) + (lam μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength (s + {lam}) μ ν + fieldStrength (s + {μ}) ν lam + + fieldStrength (s + {ν}) lam μ = 0 := by + have h : ∀ a b : Fin 1 ⊕ Fin 3, s + {a} + {b} = s + {b} + {a} := fun a b => by + rw [add_assoc, add_assoc, add_comm ({a} : Multiset (Fin 1 ⊕ Fin 3))] + simp only [fieldStrength] + rw [h lam μ, h lam ν, h μ ν] + ring + +end JetAlgebra + +end Photon + +namespace JetAlgebra + +/-! + +## B. The field strength in the QED jet algebra + +The theorems of section A, transported through the inclusion of the photon +factor into the QED jet algebra. + +-/ + +/-- The field strength is the antisymmetrised derivative of the potential, + `∂_s F_{μν} = ∂_s ∂_μ A_ν - ∂_s ∂_ν A_μ`. -/ +theorem fieldStrength_eq_sub (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength s μ ν = A (s + {μ}) ν - A (s + {ν}) μ := by + rw [fieldStrength, Photon.JetAlgebra.fieldStrength, TensorProduct.tmul_sub, + sub_tmul] + rfl + +theorem fieldStrength_antisymm (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength s μ ν = -fieldStrength s ν μ := by + simp only [fieldStrength] + rw [Photon.JetAlgebra.fieldStrength_antisymm, TensorProduct.tmul_neg, neg_tmul] + +@[simp] +theorem fieldStrength_self (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + fieldStrength s μ μ = 0 := by + simp only [fieldStrength, Photon.JetAlgebra.fieldStrength_self, + TensorProduct.tmul_zero, zero_tmul] + +/-- **The Bianchi identity** in the QED jet algebra. -/ +theorem fieldStrength_bianchi (s : Multiset (Fin 1 ⊕ Fin 3)) + (lam μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength (s + {lam}) μ ν + fieldStrength (s + {μ}) ν lam + + fieldStrength (s + {ν}) lam μ = 0 := by + simp only [fieldStrength] + rw [← add_tmul, ← add_tmul, ← TensorProduct.tmul_add, ← TensorProduct.tmul_add, + Photon.JetAlgebra.fieldStrength_bianchi, TensorProduct.tmul_zero, zero_tmul] + +/-! + +## C. The total derivative on the fields + +-/ + +/-- The first-order field-strength jet is the total derivative of the + zeroth-order one, in the photon jet algebra. -/ +theorem _root_.QED.Photon.JetAlgebra.fieldStrength_singleton_eq_jetDeriv + (ρ μ ν : Fin 1 ⊕ Fin 3) : + Photon.JetAlgebra.fieldStrength {ρ} μ ν = + Photon.JetAlgebra.jetDeriv ρ (Photon.JetAlgebra.fieldStrength 0 μ ν) := by + rw [Photon.JetAlgebra.fieldStrength, Photon.JetAlgebra.fieldStrength, map_sub, + Photon.JetAlgebra.jetDeriv_coord, Photon.JetAlgebra.jetDeriv_coord, + zero_add, zero_add, + show ({ρ} : Multiset (Fin 1 ⊕ Fin 3)) + {μ} = {μ} + {ρ} from + Multiset.add_comm _ _, + show ({ρ} : Multiset (Fin 1 ⊕ Fin 3)) + {ν} = {ν} + {ρ} from + Multiset.add_comm _ _] + +/-- The total derivative appends the derivative index to the photon jet + coordinate. -/ +@[simp] +theorem jetDeriv_A (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) : + jetDeriv ρ (A s μ) = A (s + {ρ}) μ := by + simp only [A] + rw [jetDeriv_tmul, Electron.JetAlgebra.jetDeriv_one, tmul_zero, add_zero, + LinearMap.baseChange_tmul, Photon.JetAlgebra.jetDeriv_coord] + +/-- The total derivative appends the derivative index to the electron jet + coordinate. -/ +@[simp] +theorem jetDeriv_ψ (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (α : Fin 2 ⊕ Fin 2) : + jetDeriv ρ (ψ s α) = ψ (s + {ρ}) α := by + simp only [ψ] + rw [jetDeriv_tmul, show (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) = + (1 : ℂ) ⊗ₜ[ℝ] (1 : Photon.JetAlgebra) from rfl, LinearMap.baseChange_tmul, + Photon.JetAlgebra.jetDeriv_one, TensorProduct.tmul_zero, zero_tmul, zero_add, + Electron.JetAlgebra.jetDeriv_ofGenerator] + rfl + +@[simp] +theorem jetDeriv_barψ (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (α : Fin 2 ⊕ Fin 2) : + jetDeriv ρ (barψ s α) = barψ (s + {ρ}) α := by + simp only [barψ] + rw [jetDeriv_tmul, show (1 : ℂ ⊗[ℝ] Photon.JetAlgebra) = + (1 : ℂ) ⊗ₜ[ℝ] (1 : Photon.JetAlgebra) from rfl, LinearMap.baseChange_tmul, + Photon.JetAlgebra.jetDeriv_one, TensorProduct.tmul_zero, zero_tmul, zero_add, + Electron.JetAlgebra.jetDeriv_ofGenerator] + rfl + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/Fields.lean b/Physlib/Particles/QED/Fields.lean new file mode 100644 index 000000000..5cc83c441 --- /dev/null +++ b/Physlib/Particles/QED/Fields.lean @@ -0,0 +1,176 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Basic +public import Physlib.Relativity.PauliMatrices.Basic +/-! +# The fields of quantum electrodynamics + +## i. Overview + +The fields of QED, defined on top of the jet algebras of `Physlib.Particles.QED.Basic`: +the photon and electron jet coordinates as elements of the QED jet algebra, +the field strength, the Maxwell term, the Dirac γ matrices in the chiral +representation, and the covariant derivatives of the electron and its +conjugate. + +This file contains only definitions; the theorems about these fields are +proved in `Physlib.Particles.QED.FermionStatistics`, `Physlib.Particles.QED.FieldStrength`, +`Physlib.Particles.QED.GammaMatrices`, `Physlib.Particles.QED.GaugeInvariance` and +`Physlib.Particles.QED.Evaluation`, and the Lagrangian built from them is defined in +`Physlib.Particles.QED.Lagrangian`. + +## ii. Key results + +- `Photon.JetAlgebra.fieldStrength`, `Photon.JetAlgebra.maxwellTerm` : the + field strength and the Maxwell term in the photon jet algebra. +- `JetAlgebra.A`, `JetAlgebra.ψ`, `JetAlgebra.barψ` : the jet coordinates of + QED. +- `JetAlgebra.fieldStrength`, `JetAlgebra.maxwellTerm` : the field strength + and the Maxwell term in the QED jet algebra. +- `JetAlgebra.gammaMatrix`, `JetAlgebra.kineticGamma` : the γ matrices in the + chiral representation and the contraction matrices `γ⁰ γ^μ`. +- `JetAlgebra.covDψ`, `JetAlgebra.covDbarψ` : the covariant derivatives. + +## iii. Table of contents + +- A. The field strength and Maxwell term of the photon +- B. The jet coordinates of QED +- C. The γ matrices in the chiral representation +- D. The covariant derivatives + +## iv. References + +The jet algebras are defined in `Physlib.Particles.QED.Basic`; the Lagrangian is +defined in `Physlib.Particles.QED.Lagrangian`. + +-/ + +@[expose] public section + +namespace QED + +open minkowskiMatrix +open scoped PauliMatrix + +namespace Photon + +namespace JetAlgebra + +/-! + +## A. The field strength and Maxwell term of the photon + +-/ + +/-- The formal field strength `∂_s F_{μν} = ∂_s ∂_μ A_ν - ∂_s ∂_ν A_μ`. -/ +noncomputable def fieldStrength (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + JetAlgebra := + coord (s + {μ}) ν - coord (s + {ν}) μ + +/-- The formal Maxwell term `F_{μν} F^{μν}`, both indices raised with the + (diagonal) Minkowski metric. -/ +noncomputable def maxwellTerm : JetAlgebra := + ∑ μ, ∑ ν, (η μ μ * η ν ν) • (fieldStrength 0 μ ν * fieldStrength 0 μ ν) + +/-- The Maxwell operator `∂_μ F^{μν}`: the divergence of the field strength + with raised indices. Its vanishing is the vacuum Maxwell equation; its + evaluation on an honest potential is the Euler–Lagrange gradient of the + Maxwell action — see `Physlib.Particles.QED.Evaluation`. -/ +noncomputable def maxwellOperator (ν : Fin 1 ⊕ Fin 3) : JetAlgebra := + ∑ μ, (η μ μ * η ν ν) • fieldStrength {μ} μ ν + +end JetAlgebra + +end Photon + +namespace JetAlgebra + +/-! + +## B. The jet coordinates of QED + +The photon jet coordinate `∂_s A_μ` and the electron jet coordinates +`∂_s ψ_α`, `∂_s ψ̄_α`, as elements of the QED jet algebra, together with the +field strength and the Maxwell term. + +-/ + +/-- The photon jet coordinate `∂_s A_μ` in the QED jet algebra. -/ +noncomputable def A (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + JetAlgebra := + ((1 : ℂ) ⊗ₜ[ℝ] Photon.JetAlgebra.coord s μ) ⊗ⱼ 1 + +/-- The electron jet coordinate `∂_s ψ_α` in the QED jet algebra. -/ +noncomputable def ψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + JetAlgebra := + 1 ⊗ⱼ Electron.JetAlgebra.ofGenerator (.dψ s α) + +/-- The conjugate electron jet coordinate `∂_s ψ̄_α` in the QED jet algebra. -/ +noncomputable def barψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + JetAlgebra := + 1 ⊗ⱼ Electron.JetAlgebra.ofGenerator (.dbarψ s α) + +/-- The formal field strength `∂_s F_{μν}` in the QED jet algebra. -/ +noncomputable def fieldStrength (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) : JetAlgebra := + ((1 : ℂ) ⊗ₜ[ℝ] Photon.JetAlgebra.fieldStrength s μ ν) ⊗ⱼ 1 + +/-- The formal Maxwell term `F_{μν} F^{μν}` in the QED jet algebra. Its + evaluation on an honest electromagnetic potential is the Maxwell Lagrangian; + see `Physlib.Particles.QED.Evaluation`. -/ +noncomputable def maxwellTerm : JetAlgebra := + ((1 : ℂ) ⊗ₜ[ℝ] Photon.JetAlgebra.maxwellTerm) ⊗ⱼ 1 + +/-! + +## C. The γ matrices in the chiral representation + +In the chiral representation `γ^μ = ((0, σ^μ), (σ̄^μ, 0))` with +`σ^μ = (1, σ^i)` and `σ̄^μ = (1, -σ^i)`; since the Minkowski matrix is +diagonal, `σ̄^μ = η_{μμ} σ^μ` with no sum over `μ`. + +-/ + +/-- The Dirac γ matrices in the chiral (Weyl) representation: + `γ^μ = ((0, σ^μ), (σ̄^μ, 0))`, acting on the Dirac index `Fin 2 ⊕ Fin 2` + whose summands are the left- and right-handed Weyl components. -/ +noncomputable def gammaMatrix (μ : Fin 1 ⊕ Fin 3) : + Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ := + Matrix.fromBlocks 0 (σ μ) (η μ μ • σ μ) 0 + +/-- The contraction matrices `γ⁰ γ^μ = ((σ̄^μ, 0), (0, σ^μ))` of the Dirac + kinetic term `i ψ† (γ⁰ γ^μ) D_μ ψ`; see + `Physlib.Particles.QED.GammaMatrices.kineticGamma_eq_gammaMatrix_mul`. -/ +noncomputable def kineticGamma (μ : Fin 1 ⊕ Fin 3) : + Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ := + Matrix.fromBlocks (η μ μ • σ μ) 0 0 (σ μ) + +/-! + +## D. The covariant derivatives + +The electron has electric charge `-1`, so `D_μ ψ = ∂_μ ψ + i e A_μ ψ` and +`D_μ ψ̄ = ∂_μ ψ̄ - i e A_μ ψ̄`, with `e` the electric coupling. + +-/ + +/-- The covariant derivative jet `(D_μ ψ)_α = ∂_μ ψ_α + i e A_μ ψ_α` of the + electron. -/ +noncomputable def covDψ (e : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + JetAlgebra := + ψ {μ} α + (Complex.I * e) • (A 0 μ * ψ 0 α) + +/-- The covariant derivative jet `(D_μ ψ̄)_α = ∂_μ ψ̄_α - i e A_μ ψ̄_α` of the + conjugate electron. -/ +noncomputable def covDbarψ (e : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + JetAlgebra := + barψ {μ} α - (Complex.I * e) • (A 0 μ * barψ 0 α) + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/GammaMatrices.lean b/Physlib/Particles/QED/GammaMatrices.lean new file mode 100644 index 000000000..c5d91604a --- /dev/null +++ b/Physlib/Particles/QED/GammaMatrices.lean @@ -0,0 +1,168 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Fields +/-! +# Properties of the γ matrices + +## i. Overview + +The defining properties of the Dirac γ matrices of `Physlib.Particles.QED.Fields`, in +the chiral representation: + +* the **Clifford algebra relation** `γ^μ γ^ν + γ^ν γ^μ = 2 η^{μν} 1`, which + makes the Dirac operator a square root of the wave operator; +* the hermiticity properties `(γ⁰ γ^μ)† = γ⁰ γ^μ` and + `(γ^μ)† = γ⁰ γ^μ γ⁰`, which make the Dirac Lagrangian hermitian; +* the factorisation `γ⁰ γ^μ` of the contraction matrices of the kinetic term. + +This file contains no definitions, only theorems about the fields of +`Physlib.Particles.QED.Fields`. + +## ii. Key results + +- `JetAlgebra.gammaMatrix_mul_add_swap` : **the Clifford algebra relation**. +- `JetAlgebra.kineticGamma_eq_gammaMatrix_mul` : the contraction matrices of + the kinetic term are `γ⁰ γ^μ`. +- `JetAlgebra.kineticGamma_conjTranspose` : the contraction matrices are + self-adjoint. +- `JetAlgebra.gammaMatrix_conjTranspose` : `(γ^μ)† = γ⁰ γ^μ γ⁰`. + +## iii. Table of contents + +- A. The Pauli anticommutators +- B. The Clifford algebra relation +- C. Hermiticity + +## iv. References + +The γ matrices are defined in `Physlib.Particles.QED.Fields`; the Pauli matrices are +those of `Physlib.Relativity.PauliMatrices`. + +-/ + +@[expose] public section + +namespace QED + +namespace JetAlgebra + +open Matrix minkowskiMatrix +open scoped PauliMatrix + +/-! + +## A. The Pauli anticommutators + +The two block identities behind the Clifford relation: +`σ^μ σ̄^ν + σ^ν σ̄^μ = 2 η^{μν} 1` and `σ̄^μ σ^ν + σ̄^ν σ^μ = 2 η^{μν} 1`, +with `σ̄^μ = η_{μμ} σ^μ` (no sum). Both reduce to the anticommutation +relations of the Pauli matrices. + +-/ + +lemma pauliMatrix_mul_smul_add_swap (μ ν : Fin 1 ⊕ Fin 3) : + σ μ * (η ν ν • σ ν) + σ ν * (η μ μ • σ μ) = + (2 * η μ ν) • (1 : Matrix (Fin 2) (Fin 2) ℂ) := by + fin_cases μ <;> fin_cases ν <;> + simp [PauliMatrix.pauliMatrix_mul_self, two_smul, + PauliMatrix.pauliMatrix_inl_zero_eq_one] + +lemma smul_pauliMatrix_mul_add_swap (μ ν : Fin 1 ⊕ Fin 3) : + (η μ μ • σ μ) * σ ν + (η ν ν • σ ν) * σ μ = + (2 * η μ ν) • (1 : Matrix (Fin 2) (Fin 2) ℂ) := by + fin_cases μ <;> fin_cases ν <;> + simp [PauliMatrix.pauliMatrix_mul_self, two_smul, + PauliMatrix.pauliMatrix_inl_zero_eq_one] + +/-! + +## B. The Clifford algebra relation + +-/ + +/-- **The Clifford algebra relation** of the Dirac γ matrices: + `γ^μ γ^ν + γ^ν γ^μ = 2 η^{μν} 1`. This is the algebraic identity that + makes the Dirac operator a square root of the wave operator, and hence the + Dirac equation relativistic. -/ +theorem gammaMatrix_mul_add_swap (μ ν : Fin 1 ⊕ Fin 3) : + gammaMatrix μ * gammaMatrix ν + gammaMatrix ν * gammaMatrix μ = + (2 * η μ ν) • (1 : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ) := by + rw [gammaMatrix, gammaMatrix, Matrix.fromBlocks_multiply, + Matrix.fromBlocks_multiply, Matrix.fromBlocks_add, + show ((2 * η μ ν) • (1 : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ)) = + Matrix.fromBlocks ((2 * η μ ν) • 1) 0 0 ((2 * η μ ν) • 1) by + rw [← Matrix.fromBlocks_one, Matrix.fromBlocks_smul, smul_zero]] + congr 1 + · simpa using pauliMatrix_mul_smul_add_swap μ ν + · simp + · simp + · simpa using smul_pauliMatrix_mul_add_swap μ ν + +/-- The square of a γ matrix: `(γ^μ)² = η^{μμ} 1` (no sum). -/ +theorem gammaMatrix_sq (μ : Fin 1 ⊕ Fin 3) : + gammaMatrix μ * gammaMatrix μ = + (η μ μ) • (1 : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ) := by + rw [gammaMatrix, Matrix.fromBlocks_multiply, + show ((η μ μ) • (1 : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ)) = + Matrix.fromBlocks ((η μ μ) • 1) 0 0 ((η μ μ) • 1) by + rw [← Matrix.fromBlocks_one, Matrix.fromBlocks_smul, smul_zero]] + congr 1 <;> simp [PauliMatrix.pauliMatrix_mul_self] + +/-- The γ matrices of distinct indices anticommute. -/ +theorem gammaMatrix_anticommute {μ ν : Fin 1 ⊕ Fin 3} (h : μ ≠ ν) : + gammaMatrix μ * gammaMatrix ν = -(gammaMatrix ν * gammaMatrix μ) := by + have hc := gammaMatrix_mul_add_swap μ ν + rw [off_diag_zero h] at hc + simp only [mul_zero, zero_smul] at hc + exact eq_neg_of_add_eq_zero_left hc + +/-! + +## C. Hermiticity + +-/ + +/-- `γ⁰` in the chiral representation is the block off-diagonal identity. -/ +theorem gammaMatrix_inl_zero : + gammaMatrix (Sum.inl 0) = Matrix.fromBlocks 0 1 1 0 := by + rw [gammaMatrix] + simp [PauliMatrix.pauliMatrix_inl_zero_eq_one] + +/-- The contraction matrices of the kinetic term are `γ⁰ γ^μ`. -/ +theorem kineticGamma_eq_gammaMatrix_mul (μ : Fin 1 ⊕ Fin 3) : + kineticGamma μ = gammaMatrix (Sum.inl 0) * gammaMatrix μ := by + rw [kineticGamma, gammaMatrix, gammaMatrix, Matrix.fromBlocks_multiply] + simp [PauliMatrix.pauliMatrix_inl_zero_eq_one] + +/-- The contraction matrices `γ⁰ γ^μ` of the kinetic term are self-adjoint; + this is what makes the Dirac kinetic term hermitian up to a total + derivative. -/ +theorem kineticGamma_conjTranspose (μ : Fin 1 ⊕ Fin 3) : + (kineticGamma μ)ᴴ = kineticGamma μ := by + fin_cases μ <;> + simp [kineticGamma, Matrix.fromBlocks_conjTranspose, + PauliMatrix.pauliMatrix_selfAdjoint] + +/-- `γ⁰` is self-adjoint. -/ +theorem gammaMatrix_zero_conjTranspose : + (gammaMatrix (Sum.inl 0))ᴴ = gammaMatrix (Sum.inl 0) := by + simp [gammaMatrix, Matrix.fromBlocks_conjTranspose, + PauliMatrix.pauliMatrix_inl_zero_eq_one] + +/-- The hermiticity relation of the γ matrices, `(γ^μ)† = γ⁰ γ^μ γ⁰`. -/ +theorem gammaMatrix_conjTranspose (μ : Fin 1 ⊕ Fin 3) : + (gammaMatrix μ)ᴴ = + gammaMatrix (Sum.inl 0) * gammaMatrix μ * gammaMatrix (Sum.inl 0) := by + fin_cases μ <;> + simp [gammaMatrix, Matrix.fromBlocks_conjTranspose, + Matrix.fromBlocks_multiply, PauliMatrix.pauliMatrix_selfAdjoint, + PauliMatrix.pauliMatrix_inl_zero_eq_one] + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/GaugeInvariance.lean b/Physlib/Particles/QED/GaugeInvariance.lean new file mode 100644 index 000000000..4e833a9d9 --- /dev/null +++ b/Physlib/Particles/QED/GaugeInvariance.lean @@ -0,0 +1,501 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Lagrangian +public import Mathlib.Tactic.Module +/-! +# Gauge invariance of quantum electrodynamics + +## i. Overview + +The gauge-theoretic theorems of QED, culminating in the gauge invariance of +the QED Lagrangian, `gaugeAction_lagrangian`. The chain of results +decomposes exactly as in the physics texts: + +* on the photon jet algebra the gauge transformations form a group acting by + affine shifts (`Photon.JetAlgebra.gaugeAction_comp`), and the field + strength and the Maxwell term are invariant because the shift of `∂_s A_μ` + is symmetric in the derivative indices — Clairaut's theorem is built into + the multiset indexing (`Photon.JetAlgebra.gaugeAction_fieldStrength`); +* the electron coordinates rotate by the phase and its conjugate, and the + trivial gauge jet acts trivially (`Electron.JetAlgebra.gaugeAction_trivial`); +* the covariant derivative is covariant, `D_μ ψ ↦ ū D_μ ψ`, because the + photon shift `∂_μ χ` cancels the derivative `∂_μ ū = -i e (∂_μ χ) ū` of + the phase (`gaugeAction_covDψ`); +* every charge-neutral fermion bilinear is invariant because the phases of + the electron and its conjugate cancel by unitarity + (`gaugeAction_mul_phase_cancel`); +* the Lagrangian, being built from invariant pieces, is invariant + (`gaugeAction_lagrangian`). + +This file contains no definitions, only theorems about the jet algebras of +`Physlib.Particles.QED.Basic`, the fields of `Physlib.Particles.QED.Fields` and the Lagrangian of +`Physlib.Particles.QED.Lagrangian`. + +## ii. Key results + +- `Photon.JetAlgebra.gaugeAction_comp`, `Photon.JetAlgebra.gaugeAction_zero` : + the photon gauge transformations form a group acting on the photon jet + algebra. +- `Photon.JetAlgebra.gaugeAction_fieldStrength`, + `Photon.JetAlgebra.gaugeAction_maxwellTerm` : gauge invariance of the field + strength and the Maxwell term. +- `Electron.JetAlgebra.gaugeAction_trivial`, `JetAlgebra.gaugeAction_trivial` : + the trivial gauge jet acts trivially. +- `JetAlgebra.gaugeAction_A`, `JetAlgebra.gaugeAction_ψ_zero`, + `JetAlgebra.gaugeAction_ψ_singleton` (and the `barψ` versions) : the action + on the jet coordinates of QED. +- `JetAlgebra.gaugeAction_covDψ`, `JetAlgebra.gaugeAction_covDbarψ` : gauge + covariance of the covariant derivatives. +- `JetAlgebra.gaugeAction_diracKineticTerm`, + `JetAlgebra.gaugeAction_electronMassTerm` : gauge invariance of the terms + of the Lagrangian. +- `JetAlgebra.gaugeAction_lagrangian` : **gauge invariance of the QED + Lagrangian**. + +## iii. Table of contents + +- A. The gauge group acting on the photon jet algebra + - A.1. Gauge invariance of the field strength and the Maxwell term +- B. The trivial gauge jet acts trivially +- C. The action on the jet coordinates of QED + - C.1. The photon coordinates + - C.2. The electron coordinates + - C.3. The field strength and the Maxwell term +- D. Gauge covariance of the covariant derivatives +- E. Gauge invariance of the Lagrangian + - E.1. Cancellation of the phases in fermion bilinears + - E.2. Invariance of each term + - E.3. Invariance of the QED Lagrangian + +## iv. References + +The jet algebras and gauge actions are defined in `Physlib.Particles.QED.Basic`, the +fields in `Physlib.Particles.QED.Fields` and the Lagrangian in +`Physlib.Particles.QED.Lagrangian`. + +-/ + +@[expose] public section + +namespace QED + +open TensorProduct + +namespace Photon + +namespace JetAlgebra + +/-! + +## A. The gauge group acting on the photon jet algebra + +-/ + +/-- Photon gauge jets compose by addition: the gauge transformations form a + group acting on the photon jet algebra. -/ +theorem gaugeAction_comp (c₁ c₂ : GaugeJet) : + (gaugeAction c₁).comp (gaugeAction c₂) = gaugeAction (c₁ + c₂) := by + refine MvPolynomial.algHom_ext fun j => ?_ + obtain ⟨s, μ⟩ := j + rw [AlgHom.comp_apply] + show gaugeAction c₁ (gaugeAction c₂ (coord s μ)) = gaugeAction (c₁ + c₂) (coord s μ) + rw [gaugeAction_coord, gaugeAction_coord, map_add, gaugeAction_coord, gaugeAction_C, + add_assoc, ← MvPolynomial.C_add] + rfl + +@[simp] +theorem gaugeAction_zero : gaugeAction 0 = AlgHom.id ℝ JetAlgebra := by + refine MvPolynomial.algHom_ext fun j => ?_ + obtain ⟨s, μ⟩ := j + show gaugeAction 0 (coord s μ) = coord s μ + simp + +/-! + +### A.1. Gauge invariance of the field strength and the Maxwell term + +The field strength is gauge invariant, and the reason is exactly that +multiset addition is commutative: the two shifts are `∂_s ∂_μ ∂_ν χ` and +`∂_s ∂_ν ∂_μ χ`, indexed by `s + {μ} + {ν}` and `s + {ν} + {μ}`. Clairaut's +theorem is built into the indexing. + +-/ + +@[simp] +theorem gaugeAction_fieldStrength (c : GaugeJet) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) : + gaugeAction c (fieldStrength s μ ν) = fieldStrength s μ ν := by + have hcomm : s + {μ} + {ν} = s + {ν} + {μ} := by + rw [add_assoc, add_assoc, add_comm ({μ} : Multiset _)] + rw [fieldStrength, map_sub, gaugeAction_coord, gaugeAction_coord, hcomm] + ring + +@[simp] +theorem gaugeAction_maxwellTerm (c : GaugeJet) : gaugeAction c maxwellTerm = maxwellTerm := by + rw [maxwellTerm, map_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_smul, map_mul, gaugeAction_fieldStrength] + +end JetAlgebra + +end Photon + +/-! + +## B. The trivial gauge jet acts trivially + +The key combinatorial fact: in the Leibniz sum over the antidiagonal of `t`, +the splitting `(0, t)` occurs exactly once, so an indicator supported at the +zero multiset picks out the identity. + +-/ + +namespace Electron + +namespace JetAlgebra + +/-- The trivial gauge jet acts trivially on the electron jet algebra: the + gauge action is unital. -/ +theorem gaugeAction_trivial (e : ℝ) : + gaugeAction (GaugeJet.trivial e) = AlgHom.id ℂ JetAlgebra := by + refine ExteriorAlgebra.hom_ext (Finsupp.lhom_ext fun j b => ?_) + simp only [LinearMap.coe_comp, Function.comp_apply, AlgHom.toLinearMap_apply, + AlgHom.coe_id, id_eq] + rw [← Finsupp.smul_single_one, map_smul, map_smul] + congr 1 + show gaugeAction (GaugeJet.trivial e) (ofGenerator j) = ofGenerator j + cases j with + | dψ t α => + rw [gaugeAction_ofGenerator_dψ, + show (t.antidiagonal.map fun p => + star ((GaugeJet.trivial e).phase p.1) • ofGenerator (.dψ p.2 α)) = + t.antidiagonal.map fun p => + if p.1 = 0 then ofGenerator (.dψ p.2 α) else 0 from + Multiset.map_congr rfl fun p _ => by + by_cases h : p.1 = 0 <;> simp [GaugeJet.trivial, h], + sum_map_antidiagonal_ite t fun u => ofGenerator (.dψ u α)] + | dbarψ t α => + rw [gaugeAction_ofGenerator_dbarψ, + show (t.antidiagonal.map fun p => + (GaugeJet.trivial e).phase p.1 • ofGenerator (.dbarψ p.2 α)) = + t.antidiagonal.map fun p => + if p.1 = 0 then ofGenerator (.dbarψ p.2 α) else 0 from + Multiset.map_congr rfl fun p _ => by + by_cases h : p.1 = 0 <;> simp [GaugeJet.trivial, h], + sum_map_antidiagonal_ite t fun u => ofGenerator (.dbarψ u α)] + +end JetAlgebra + +end Electron + +namespace JetAlgebra + +/-- The trivial gauge jet acts trivially on the QED jet algebra: the gauge + action is unital. -/ +theorem gaugeAction_trivial (e : ℝ) : + gaugeAction (GaugeJet.trivial e) = AlgHom.id ℂ JetAlgebra := by + have hP : gaugeActionPhoton (GaugeJet.trivial e).χjet = + AlgHom.id ℂ (ℂ ⊗[ℝ] Photon.JetAlgebra) := by + rw [show (GaugeJet.trivial e).χjet = 0 from rfl, gaugeActionPhoton, + Photon.JetAlgebra.gaugeAction_zero, Algebra.TensorProduct.map_id] + simp only [gaugeAction, hP, Electron.JetAlgebra.gaugeAction_trivial] + exact Algebra.TensorProduct.map_id + +/-- The electron gauge actions compose through the monoid of gauge jets. -/ +theorem _root_.QED.Electron.JetAlgebra.gaugeAction_mul {e : ℝ} (g₁ g₂ : GaugeJet e) : + (Electron.JetAlgebra.gaugeAction g₁).comp (Electron.JetAlgebra.gaugeAction g₂) = + Electron.JetAlgebra.gaugeAction (g₁ * g₂) := by + refine ExteriorAlgebra.hom_ext (Finsupp.lhom_ext fun j b => ?_) + simp only [LinearMap.coe_comp, Function.comp_apply, AlgHom.toLinearMap_apply, + AlgHom.comp_apply] + rw [← Finsupp.smul_single_one, map_smul, map_smul, map_smul, map_smul] + congr 1 + show Electron.JetAlgebra.gaugeAction g₁ (Electron.JetAlgebra.gaugeAction g₂ + (Electron.JetAlgebra.ofGenerator j)) = + Electron.JetAlgebra.gaugeAction (g₁ * g₂) (Electron.JetAlgebra.ofGenerator j) + cases j with + | dψ t α => + rw [Electron.JetAlgebra.gaugeAction_ofGenerator_dψ, + show (t.antidiagonal.map fun p => star (g₂.phase p.1) • + Electron.JetAlgebra.ofGenerator (.dψ p.2 α)).sum = + phaseAct (fun x => star (g₂.phase x)) + (fun t' => Electron.JetAlgebra.ofGenerator (.dψ t' α)) t from rfl, + show Electron.JetAlgebra.gaugeAction g₁ (phaseAct (fun x => star (g₂.phase x)) + (fun t' => Electron.JetAlgebra.ofGenerator (.dψ t' α)) t) = + phaseAct (fun x => star (g₂.phase x)) + (fun t' => Electron.JetAlgebra.gaugeAction g₁ + (Electron.JetAlgebra.ofGenerator (.dψ t' α))) t from + map_phaseAct _ _ (Electron.JetAlgebra.gaugeAction g₁).toLinearMap t, + show (fun t' => Electron.JetAlgebra.gaugeAction g₁ + (Electron.JetAlgebra.ofGenerator (.dψ t' α))) = + fun t' => phaseAct (fun x => star (g₁.phase x)) + (fun t'' => Electron.JetAlgebra.ofGenerator (.dψ t'' α)) t' from + funext fun t' => Electron.JetAlgebra.gaugeAction_ofGenerator_dψ g₁ t' α, + phaseAct_assoc, Electron.JetAlgebra.gaugeAction_ofGenerator_dψ, + show (t.antidiagonal.map fun p => star ((g₁ * g₂).phase p.1) • + Electron.JetAlgebra.ofGenerator (.dψ p.2 α)).sum = + phaseAct (fun x => star ((g₁ * g₂).phase x)) + (fun t' => Electron.JetAlgebra.ofGenerator (.dψ t' α)) t from rfl] + refine congrFun (congrArg (fun w => phaseAct w + (fun t' => Electron.JetAlgebra.ofGenerator (.dψ t' α))) (funext fun x => ?_)) t + rw [GaugeJet.mul_phase, star_phaseAct, phaseAct_comm] + | dbarψ t α => + rw [Electron.JetAlgebra.gaugeAction_ofGenerator_dbarψ, + show (t.antidiagonal.map fun p => g₂.phase p.1 • + Electron.JetAlgebra.ofGenerator (.dbarψ p.2 α)).sum = + phaseAct g₂.phase + (fun t' => Electron.JetAlgebra.ofGenerator (.dbarψ t' α)) t from rfl, + show Electron.JetAlgebra.gaugeAction g₁ (phaseAct g₂.phase + (fun t' => Electron.JetAlgebra.ofGenerator (.dbarψ t' α)) t) = + phaseAct g₂.phase + (fun t' => Electron.JetAlgebra.gaugeAction g₁ + (Electron.JetAlgebra.ofGenerator (.dbarψ t' α))) t from + map_phaseAct _ _ (Electron.JetAlgebra.gaugeAction g₁).toLinearMap t, + show (fun t' => Electron.JetAlgebra.gaugeAction g₁ + (Electron.JetAlgebra.ofGenerator (.dbarψ t' α))) = + fun t' => phaseAct g₁.phase + (fun t'' => Electron.JetAlgebra.ofGenerator (.dbarψ t'' α)) t' from + funext fun t' => Electron.JetAlgebra.gaugeAction_ofGenerator_dbarψ g₁ t' α, + phaseAct_assoc, Electron.JetAlgebra.gaugeAction_ofGenerator_dbarψ, + show (t.antidiagonal.map fun p => (g₁ * g₂).phase p.1 • + Electron.JetAlgebra.ofGenerator (.dbarψ p.2 α)).sum = + phaseAct ((g₁ * g₂).phase) + (fun t' => Electron.JetAlgebra.ofGenerator (.dbarψ t' α)) t from rfl] + refine congrFun (congrArg (fun w => phaseAct w + (fun t' => Electron.JetAlgebra.ofGenerator (.dbarψ t' α))) (funext fun x => ?_)) t + rw [GaugeJet.mul_phase, phaseAct_comm] + +/-- The complexified photon gauge actions compose by addition of the gauge + jets. -/ +theorem gaugeActionPhoton_comp (c₁ c₂ : Photon.JetAlgebra.GaugeJet) : + (gaugeActionPhoton c₁).comp (gaugeActionPhoton c₂) = + gaugeActionPhoton (c₁ + c₂) := by + rw [gaugeActionPhoton, gaugeActionPhoton, gaugeActionPhoton, + ← Algebra.TensorProduct.map_comp, AlgHom.comp_id, + Photon.JetAlgebra.gaugeAction_comp] + +/-- **The gauge actions compose through the monoid of gauge jets**: the QED + gauge action is a monoid action on the jet algebra. -/ +theorem gaugeAction_mul {e : ℝ} (g₁ g₂ : GaugeJet e) : + (gaugeAction g₁).comp (gaugeAction g₂) = gaugeAction (g₁ * g₂) := by + simp only [gaugeAction, GaugeJet.mul_χjet] + rw [← gaugeActionPhoton_comp, ← Electron.JetAlgebra.gaugeAction_mul] + exact (Algebra.TensorProduct.map_comp _ _ _ _).symm + +theorem gaugeAction_mul_apply {e : ℝ} (g₁ g₂ : GaugeJet e) (x : JetAlgebra) : + gaugeAction (g₁ * g₂) x = gaugeAction g₁ (gaugeAction g₂ x) := + (DFunLike.congr_fun (gaugeAction_mul g₁ g₂) x).symm + +/-! + +## C. The action on the jet coordinates of QED + +### C.1. The photon coordinates + +The photon coordinate shifts by a *constant* of the jet algebra, the jet +`∂_s ∂_μ χ` of the gauge function; in the full algebra the constant is the +scalar multiple `(∂_s ∂_μ χ) • 1`. + +-/ + +/-- The gauge action on the photon jet coordinate: the affine shift + `∂_s A_μ ↦ ∂_s A_μ + ∂_s ∂_μ χ`. -/ +theorem gaugeAction_A {e : ℝ} (g : GaugeJet e) (s : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) : + gaugeAction g (A s μ) = A s μ + (g.χjet (s + {μ}) : ℂ) • 1 := by + simp only [A] + rw [gaugeAction_tmul, map_one, gaugeActionPhoton_tmul, + Photon.JetAlgebra.gaugeAction_coord, TensorProduct.tmul_add, add_tmul, + tmul_C_eq_smul_one] + +/-! + +### C.2. The electron coordinates + +The electron (charge `-1`) rotates by the conjugate phase, its conjugate +(charge `+1`) by the phase; on first-order jets the Leibniz rule feeds the +first derivative of the phase into the zeroth-order coordinate. + +-/ + +@[simp] +theorem gaugeAction_ψ_zero {e : ℝ} (g : GaugeJet e) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ψ 0 α) = star (g.phase 0) • ψ 0 α := by + simp only [ψ] + rw [gaugeAction_tmul, map_one, + Electron.JetAlgebra.gaugeAction_ofGenerator_dψ_zero, tmul_smul] + +@[simp] +theorem gaugeAction_barψ_zero {e : ℝ} (g : GaugeJet e) (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (barψ 0 α) = g.phase 0 • barψ 0 α := by + simp only [barψ] + rw [gaugeAction_tmul, map_one, + Electron.JetAlgebra.gaugeAction_ofGenerator_dbarψ_zero, tmul_smul] + +theorem gaugeAction_ψ_singleton {e : ℝ} (g : GaugeJet e) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (ψ {μ} α) = + star (g.phase 0) • ψ {μ} α + star (g.phase {μ}) • ψ 0 α := by + simp only [ψ] + rw [gaugeAction_tmul, map_one, + Electron.JetAlgebra.gaugeAction_ofGenerator_dψ_singleton, tmul_add, + tmul_smul, tmul_smul] + +theorem gaugeAction_barψ_singleton {e : ℝ} (g : GaugeJet e) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (barψ {μ} α) = + g.phase 0 • barψ {μ} α + g.phase {μ} • barψ 0 α := by + simp only [barψ] + rw [gaugeAction_tmul, map_one, + Electron.JetAlgebra.gaugeAction_ofGenerator_dbarψ_singleton, tmul_add, + tmul_smul, tmul_smul] + +/-! + +### C.3. The field strength and the Maxwell term + +Both invariances are inherited from the photon jet algebra, where the proof +is the commutativity of multiset addition. + +-/ + +@[simp] +theorem gaugeAction_fieldStrength {e : ℝ} (g : GaugeJet e) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + gaugeAction g (fieldStrength s μ ν) = fieldStrength s μ ν := by + simp only [fieldStrength] + rw [gaugeAction_tmul, map_one, gaugeActionPhoton_tmul, + Photon.JetAlgebra.gaugeAction_fieldStrength] + +@[simp] +theorem gaugeAction_maxwellTerm {e : ℝ} (g : GaugeJet e) : + gaugeAction g maxwellTerm = maxwellTerm := by + simp only [maxwellTerm] + rw [gaugeAction_tmul, map_one, gaugeActionPhoton_tmul, + Photon.JetAlgebra.gaugeAction_maxwellTerm] + +/-! + +## D. Gauge covariance of the covariant derivatives + +Under a gauge transformation the photon coordinate shifts by `∂_μ χ` while +the first-order electron coordinate picks up the derivative +`∂_μ ū = -i e (∂_μ χ) ū` of the phase by the Leibniz rule; the two +contributions cancel and the covariant derivative rotates like the field +itself. + +-/ + +/-- **Gauge covariance of the covariant derivative**: `D_μ ψ` rotates by the + conjugate phase, exactly like `ψ` itself. The shift of the photon + coordinate cancels the derivative of the phase. -/ +theorem gaugeAction_covDψ {e : ℝ} (g : GaugeJet e) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (covDψ e μ α) = star (g.phase 0) • covDψ e μ α := by + rw [covDψ, map_add, map_smul, map_mul, gaugeAction_ψ_singleton, + gaugeAction_ψ_zero, gaugeAction_A, g.star_phase_singleton μ, + show (0 : Multiset (Fin 1 ⊕ Fin 3)) + {μ} = {μ} from zero_add _] + simp only [add_mul, smul_mul_assoc, one_mul, mul_smul_comm, smul_add, + smul_smul, neg_smul] + module + +/-- Gauge covariance of the conjugate covariant derivative: `D_μ ψ̄` rotates + by the phase, exactly like `ψ̄` itself. -/ +theorem gaugeAction_covDbarψ {e : ℝ} (g : GaugeJet e) (μ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + gaugeAction g (covDbarψ e μ α) = g.phase 0 • covDbarψ e μ α := by + rw [covDbarψ, map_sub, map_smul, map_mul, gaugeAction_barψ_singleton, + gaugeAction_barψ_zero, gaugeAction_A, g.phase_singleton μ, + show (0 : Multiset (Fin 1 ⊕ Fin 3)) + {μ} = {μ} from zero_add _] + simp only [add_mul, smul_mul_assoc, one_mul, mul_smul_comm, smul_add, + smul_sub, smul_smul] + module + +/-! + +## E. Gauge invariance of the Lagrangian + +### E.1. Cancellation of the phases in fermion bilinears + +-/ + +/-- A product of a factor rotating by the phase and a factor rotating by the + conjugate phase is gauge invariant: the phases cancel by unitarity. This is + the reason every charge-neutral fermion bilinear of QED is gauge + invariant. -/ +theorem gaugeAction_mul_phase_cancel {e : ℝ} (g : GaugeJet e) {x y : JetAlgebra} + (hx : gaugeAction g x = g.phase 0 • x) + (hy : gaugeAction g y = star (g.phase 0) • y) : + gaugeAction g (x * y) = x * y := by + rw [map_mul, hx, hy, smul_mul_smul_comm, g.phase_zero_unitary, one_smul] + +/-! + +### E.2. Invariance of each term + +-/ + +@[simp] +theorem gaugeAction_diracKineticTerm {e : ℝ} (g : GaugeJet e) : + gaugeAction g (diracKineticTerm e) = diracKineticTerm e := by + rw [diracKineticTerm, map_smul, map_sum] + congr 1 + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, + gaugeAction_mul_phase_cancel g (gaugeAction_barψ_zero g α) + (gaugeAction_covDψ g μ β)] + +@[simp] +theorem gaugeAction_diracKineticTermBar {e : ℝ} (g : GaugeJet e) : + gaugeAction g (diracKineticTermBar e) = diracKineticTermBar e := by + rw [diracKineticTermBar, map_smul, map_sum] + congr 1 + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, + gaugeAction_mul_phase_cancel g (gaugeAction_covDbarψ g μ α) + (gaugeAction_ψ_zero g β)] + +@[simp] +theorem gaugeAction_electronMassTerm {e : ℝ} (g : GaugeJet e) : + gaugeAction g electronMassTerm = electronMassTerm := by + rw [electronMassTerm, map_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, + gaugeAction_mul_phase_cancel g (gaugeAction_barψ_zero g α) + (gaugeAction_ψ_zero g β)] + +/-! + +### E.3. Invariance of the QED Lagrangian + +-/ + +/-- **Gauge invariance of the QED Lagrangian.** The Maxwell term is invariant + by the symmetry of the photon shift in its derivative indices, the kinetic + term by the covariance of the covariant derivative, and the mass term by the + unitarity of the phase. -/ +theorem gaugeAction_lagrangian {e : ℝ} (g : GaugeJet e) (m : ℝ) : + gaugeAction g (lagrangian e m) = lagrangian e m := by + rw [lagrangian, map_sub, map_add, map_smul, map_smul, gaugeAction_maxwellTerm, + gaugeAction_diracKineticTerm, gaugeAction_electronMassTerm] + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/JetCompleteness.lean b/Physlib/Particles/QED/JetCompleteness.lean new file mode 100644 index 000000000..1b51540d2 --- /dev/null +++ b/Physlib/Particles/QED/JetCompleteness.lean @@ -0,0 +1,216 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.GaugeInvariance +public import Physlib.Mathematics.MvPolynomialTranslation +/-! +# Completeness of the field strength for gauge invariance + +## i. Overview + +The classification of the gauge invariants of the photon jet algebra: +**an element of the photon jet algebra is invariant under every gauge +transformation if and only if it is a polynomial in the derivatives +`∂_s F_{μν}` of the field strength** — +`gaugeInvariant_iff_mem_adjoin_fieldStrength`. + +One direction is the gauge invariance of the field strength. For the other, +the gauge action translates all jet coordinates with the same symmetrized +index class `s + {μ}` by a common arbitrary amount, so an invariant is a +polynomial in differences of same-class coordinates +(`MvPolynomial.mem_adjoin_range_X_sub_X_of_forall_aeval_add_eq`), and every +such difference is a derivative of the field strength. + +This is the abelian counterpart of the fixed-algebra theorems of +`Physlib.Particles.StandardModel.GaugeBosons.Gluons.JetCompleteness`. + +This file contains no definitions, only theorems about the jet algebras of +`Physlib.Particles.QED.Basic`. + +## ii. Key results + +- `Photon.JetAlgebra.gaugeInvariant_iff_mem_adjoin_fieldStrength` : **the + gauge invariants of the photon jet algebra are exactly the polynomials in + the derivatives of the field strength**. + +## iii. Table of contents + +- A. The symmetrized-index class projection +- B. Differences of same-class coordinates are field strengths +- C. The completeness theorem + +## iv. References + +The class projection is defined in `Physlib.Particles.QED.Basic`; the +translation-invariance engine is `Physlib.Mathematics.MvPolynomialTranslation`; +the non-abelian analogue is +`Physlib.Particles.StandardModel.GaugeBosons.Gluons.JetCompleteness`. + +-/ + +@[expose] public section + +/-! TODO: Classify the gauge- and Lorentz-invariant elements of mass dimension at most four of -/ +/-! TODO: the full QED jet algebra: the analogue for the Dirac electron of the classification -/ +/-! TODO: `LeptonGaugeSector.JetAlgebra.MassDimFour.Classification`, showing the QED Lagrangian -/ +/-! TODO: is the most general renormalizable choice. -/ + +namespace QED + +namespace Photon + +open MvPolynomial + +/-! + +## A. The symmetrized-index class projection + +-/ + +namespace JetGenerators + +lemma indexClass_dA (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + (JetGenerators.dA s μ).indexClass = s + {μ} := rfl + +lemma indexClass_ne_zero (j : JetGenerators) : j.indexClass ≠ 0 := by + obtain ⟨s, μ⟩ := j + rw [indexClass_dA] + intro h + have := congrArg Multiset.card h + simp at this + +/-- Erasing the class representative and putting it back as the Lorentz index + preserves the class. -/ +lemma indexClass_classProj (j : JetGenerators) : + j.classProj.indexClass = j.indexClass := by + rw [classProj, indexClass_dA, Multiset.add_comm, Multiset.singleton_add, + Multiset.cons_erase (classRep_mem (indexClass_ne_zero j))] + +/-- The class projection is idempotent. -/ +lemma classProj_idem (j : JetGenerators) : j.classProj.classProj = j.classProj := by + conv_lhs => rw [classProj] + rw [indexClass_classProj] + rfl + +/-- Two jet coordinates have the same class projection exactly when they lie + in the same symmetrized-index class. -/ +lemma classProj_eq_classProj_iff (j j' : JetGenerators) : + j.classProj = j'.classProj ↔ j.indexClass = j'.indexClass := by + constructor + · intro h + rw [← indexClass_classProj j, ← indexClass_classProj j', h] + · intro h + rw [classProj, classProj, h] + +end JetGenerators + +namespace JetAlgebra + +/-! + +## B. Differences of same-class coordinates are field strengths + +-/ + +/-- A jet coordinate minus the canonical coordinate of its class is a + derivative of the field strength. -/ +lemma coord_sub_classProj (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (h : (JetGenerators.dA s μ).classProj ≠ JetGenerators.dA s μ) : + (X (JetGenerators.dA s μ) : JetAlgebra) - X ((JetGenerators.dA s μ).classProj) = + fieldStrength (s.erase (classRep (s + {μ}))) (classRep (s + {μ})) μ := by + set r := classRep (s + {μ}) with hr + have hrs : r ∈ s := by + have hmem : r ∈ s + {μ} := + classRep_mem (JetGenerators.indexClass_ne_zero (.dA s μ)) + rcases Multiset.mem_add.mp hmem with hmem | hmem + · exact hmem + · exfalso + refine h ?_ + rw [Multiset.mem_singleton] at hmem + rw [JetGenerators.classProj, JetGenerators.indexClass_dA, ← hr, hmem, + show (s + {μ}).erase μ = s from by + rw [Multiset.add_comm, Multiset.singleton_add, Multiset.erase_cons_head]] + have h1 : s.erase r + {r} = s := by + rw [Multiset.add_comm, Multiset.singleton_add, Multiset.cons_erase hrs] + have h2 : s.erase r + {μ} = (s + {μ}).erase r := by + rw [Multiset.erase_add_left_pos _ hrs] + rw [fieldStrength, h1, h2, JetGenerators.classProj, JetGenerators.indexClass_dA] + rfl + +/-- Every field-strength jet lies in the range of the field-strength family. -/ +lemma fieldStrength_mem_range (t : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength t μ ν ∈ Set.range (fun p : + Multiset (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) => + fieldStrength p.1 p.2.1 p.2.2) := + ⟨⟨t, μ, ν⟩, rfl⟩ + +/-! + +## C. The completeness theorem + +-/ + +set_option maxHeartbeats 1600000 in +/-- **Completeness of the field strength for gauge invariance**: an element of + the photon jet algebra is invariant under every gauge transformation if and + only if it is a polynomial in the derivatives `∂_s F_{μν}` of the field + strength. The field strength does not just provide *some* gauge invariants + — it generates *all* of them. -/ +theorem gaugeInvariant_iff_mem_adjoin_fieldStrength (x : JetAlgebra) : + (∀ c : GaugeJet, gaugeAction c x = x) ↔ + x ∈ Algebra.adjoin ℝ (Set.range fun p : + Multiset (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3) => + fieldStrength p.1 p.2.1 p.2.2) := by + constructor + · intro hx + have key := MvPolynomial.mem_adjoin_range_X_sub_X_of_forall_aeval_add_eq + (R := ℝ) (I := JetGenerators) JetGenerators.classProj + JetGenerators.classProj_idem x ?_ + · refine Algebra.adjoin_le ?_ key + rintro y ⟨j, rfl⟩ + obtain ⟨s, μ⟩ := j + show (X (JetGenerators.dA s μ) : JetAlgebra) - + X (JetGenerators.dA s μ).classProj ∈ _ + rcases eq_or_ne (JetGenerators.dA s μ).classProj (JetGenerators.dA s μ) with + hproj | hproj + · rw [hproj, sub_self] + exact Subalgebra.zero_mem _ + · rw [coord_sub_classProj s μ hproj] + exact Algebra.subset_adjoin (fieldStrength_mem_range _ _ _) + · intro i₀ r + obtain ⟨s₀, μ₀⟩ := i₀ + have hfun : (fun i => (X i : JetAlgebra) + + C (if i.classProj = (JetGenerators.dA s₀ μ₀).classProj then r else 0)) = + fun j => match j with + | JetGenerators.dA s μ => coord s μ + + C ((fun t => if t = s₀ + {μ₀} then r else 0) (s + {μ})) := by + funext j + obtain ⟨s, μ⟩ := j + show (X (JetGenerators.dA s μ) : JetAlgebra) + _ = coord s μ + _ + rw [coord] + congr 1 + exact congrArg C (if_congr (Iff.trans + (JetGenerators.classProj_eq_classProj_iff _ _) + (by rw [JetGenerators.indexClass_dA, JetGenerators.indexClass_dA])) rfl rfl) + rw [congrArg MvPolynomial.aeval hfun] + exact hx fun t => if t = s₀ + {μ₀} then r else 0 + · intro hx c + refine Algebra.adjoin_induction ?_ ?_ ?_ ?_ hx + · rintro y ⟨⟨s, μ, ν⟩, rfl⟩ + exact gaugeAction_fieldStrength c s μ ν + · intro a + exact (gaugeAction c).commutes a + · intro a b _ _ ha hb + rw [map_add, ha, hb] + · intro a b _ _ ha hb + rw [map_mul, ha, hb] + +end JetAlgebra + +end Photon + +end QED diff --git a/Physlib/Particles/QED/Lagrangian.lean b/Physlib/Particles/QED/Lagrangian.lean new file mode 100644 index 000000000..132521b9a --- /dev/null +++ b/Physlib/Particles/QED/Lagrangian.lean @@ -0,0 +1,145 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Fields +/-! +# The QED Lagrangian + +## i. Overview + +The Lagrangian of quantum electrodynamics as an element of the QED jet +algebra: + +`L = - 1/4 F_{μν} F^{μν} + i ψ̄ γ^μ D_μ ψ - m ψ̄ ψ`, + +with `D_μ ψ = ∂_μ ψ + i e A_μ ψ` the covariant derivative of the electron +(electric charge `-1`) and the γ matrices taken in the chiral (Weyl) +representation. Here `ψ̄` denotes the conjugate jet coordinates `ψ†`; the +`γ⁰` of `ψ̄ = ψ† γ⁰` is kept explicitly in the contraction matrices +`γ⁰ γ^μ` and `γ⁰`. + +This file contains only definitions; the gauge invariance of every term and +of the full Lagrangian is proved in `Physlib.Particles.QED.GaugeInvariance`. + +## ii. Key results + +- `JetAlgebra.diracKineticTerm`, `JetAlgebra.diracKineticTermBar` : the Dirac + kinetic terms `i ψ̄ γ^μ D_μ ψ` and `-i (D_μ ψ̄) γ⁰ γ^μ ψ`. +- `JetAlgebra.electronMassTerm` : the Dirac mass term `ψ̄ ψ`. +- `JetAlgebra.diracCurrent` : the Dirac current `J^μ = ψ̄ γ^μ ψ`. +- `JetAlgebra.lagrangian` : the QED Lagrangian. + +## iii. Table of contents + +- A. The Dirac kinetic terms and the mass term +- B. The QED Lagrangian + +## iv. References + +The fields are defined in `Physlib.Particles.QED.Fields`; gauge invariance is proved in +`Physlib.Particles.QED.GaugeInvariance`. + +-/ + +@[expose] public section + +namespace QED + +open minkowskiMatrix + +namespace JetAlgebra + +/-! + +## A. The Dirac kinetic terms and the mass term + +-/ + +/-- The Dirac kinetic term `i ψ̄ γ^μ D_μ ψ = i ψ†_α (γ⁰ γ^μ)_{αβ} (D_μ ψ)_β` + of the electron. -/ +noncomputable def diracKineticTerm (e : ℝ) : JetAlgebra := + Complex.I • ∑ μ, ∑ α, ∑ β, kineticGamma μ α β • (barψ 0 α * covDψ e μ β) + +/-- The conjugate Dirac kinetic term + `-i (D_μ ψ̄) γ⁰ γ^μ ψ = -i (D_μ ψ̄)_α (γ⁰ γ^μ)_{αβ} ψ_β`; the hermitian form + of the kinetic term is the average of `diracKineticTerm` and this term. -/ +noncomputable def diracKineticTermBar (e : ℝ) : JetAlgebra := + (-Complex.I) • ∑ μ, ∑ α, ∑ β, kineticGamma μ α β • (covDbarψ e μ α * ψ 0 β) + +/-- The Dirac mass term `ψ̄ ψ = ψ†_α (γ⁰)_{αβ} ψ_β` of the electron. This is + the dimension-three term available because the electron is a Dirac fermion: + its two Weyl components have the same electric charge, so the bilinear + pairing them against the conjugate components is charge neutral. -/ +noncomputable def electronMassTerm : JetAlgebra := + ∑ α, ∑ β, gammaMatrix (Sum.inl 0) α β • (barψ 0 α * ψ 0 β) + +/-- The Dirac current `J^μ = ψ̄ γ^μ ψ = ψ†_α (γ⁰ γ^μ)_{αβ} ψ_β` of the + electron: the Noether current of the `U(1)_em` phase symmetry. Its coupling + `- e J^μ A_μ` to the photon is the entire interaction of QED — this is the + jet-algebra counterpart of the current coupling of + `Physlib.Electromagnetism.Dynamics`; see `Physlib.Particles.QED.CurrentCoupling`. -/ +noncomputable def diracCurrent (μ : Fin 1 ⊕ Fin 3) : JetAlgebra := + ∑ α, ∑ β, kineticGamma μ α β • (barψ 0 α * ψ 0 β) + +/-! + +## B. The QED Lagrangian + +-/ + +/-! + +## B'. The equations of motion + +The Euler–Lagrange equations of the QED Lagrangian, as elements of the jet +algebra whose vanishing expresses the equations of motion. Deriving them +*variationally* from `lagrangian` requires a variational calculus on the jet +algebra, which is future work; here they are definitions, and +`Physlib.Particles.QED.CurrentCoupling` proves the Noether identity that the +divergence of the Dirac current is a combination of them. + +-/ + +/-- The Dirac-equation element `γ⁰ (i γ^μ D_μ - m) ψ`, row `α`: its vanishing + is the interacting Dirac equation. -/ +noncomputable def diracEquation (e m : ℝ) (α : Fin 2 ⊕ Fin 2) : JetAlgebra := + Complex.I • ∑ μ, ∑ β, kineticGamma μ α β • covDψ e μ β - + (m : ℂ) • ∑ β, gammaMatrix (Sum.inl 0) α β • ψ 0 β + +/-- The adjoint Dirac-equation element `i (D_μ ψ̄) γ⁰ γ^μ + m ψ̄ γ⁰`, + column `β`: its vanishing is the interacting adjoint Dirac equation. -/ +noncomputable def diracAdjEquation (e m : ℝ) (β : Fin 2 ⊕ Fin 2) : JetAlgebra := + Complex.I • ∑ μ, ∑ α, kineticGamma μ α β • covDbarψ e μ α + + (m : ℂ) • ∑ α, gammaMatrix (Sum.inl 0) α β • barψ 0 α + +/-! TODO: Derive `diracEquation`, `diracAdjEquation` and `qedMaxwellEquation` variationally: -/ +/-! TODO: define the Euler–Lagrange operator on the jet algebra (the variational derivative -/ +/-! TODO: with respect to each jet coordinate) and prove they are the EL equations of -/ +/-! TODO: `lagrangian`, following `Physlib.Electromagnetism.Dynamics.IsExtrema` concretely. -/ +/-! TODO: Define the theta term `θ ε^{μνρσ} F_{μν} F_{ρσ}` and prove it is gauge invariant and -/ +/-! TODO: a total derivative for `jetDeriv`, as in the lepton–gauge sector's theta term. -/ +/-! TODO: Quantize: instantiate the field species of `Physlib.QFT.PerturbationTheory` with the -/ +/-! TODO: photon and electron of this file, towards the Feynman rules of QED. -/ + +/-- The QED Maxwell-equation element `∂_μ F^{μν} - e J^ν`: its vanishing is + the inhomogeneous Maxwell equation sourced by the Dirac current. -/ +noncomputable def qedMaxwellEquation (e : ℝ) (ν : Fin 1 ⊕ Fin 3) : JetAlgebra := + (∑ μ, ((η μ μ * η ν ν : ℝ) : ℂ) • fieldStrength {μ} μ ν) - + (e : ℂ) • diracCurrent ν + +/-- The QED Lagrangian + `L = - 1/4 F_{μν} F^{μν} + i ψ̄ γ^μ D_μ ψ - m ψ̄ ψ` + with electric coupling `e` and electron mass `m`, as an element of the QED + jet algebra. Evaluated on an honest electromagnetic potential, the first + term is the Maxwell Lagrangian of `Physlib.Electromagnetism`; see + `Physlib.Particles.QED.Evaluation`. -/ +noncomputable def lagrangian (e m : ℝ) : JetAlgebra := + (-(1 : ℂ)/4) • maxwellTerm + diracKineticTerm e - (m : ℂ) • electronMassTerm + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/LorentzInvariance.lean b/Physlib/Particles/QED/LorentzInvariance.lean new file mode 100644 index 000000000..5df57c309 --- /dev/null +++ b/Physlib/Particles/QED/LorentzInvariance.lean @@ -0,0 +1,606 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Lagrangian +public import Physlib.Particles.QED.GammaMatrices +/-! +# Lorentz invariance of quantum electrodynamics + +## i. Overview + +The Lorentz-theoretic theorems of QED, culminating in the Lorentz invariance +of the QED Lagrangian, `lorentzAction_lagrangian`. The chain of results: + +* the covering map `Lorentz.SL2C.toLorentzGroup` intertwines the conjugation + of the covariant Pauli matrices with the Lorentz transformation of their + index; combined with the defining property `Λ η Λᵀ = η` of the Lorentz + group this yields the two contraction identities of the spinor + representation (`sum_lorentz_inv_conjTranspose_pauli_conj` and + `sum_lorentz_inv_eta_pauli_conj`), which assemble block-diagonally into + the contraction identity of the kinetic matrices `γ⁰ γ^μ` + (`sum_kineticGamma_contraction`); +* the jet coordinates of QED transform as tensors and spinors + (`lorentzAction_A_zero`, `lorentzAction_ψ_singleton`, …), and the covariant + derivative transforms exactly like the first-order jet + (`lorentzAction_covDψ`); +* the Maxwell term is invariant because `Λ⁻¹ η (Λ⁻¹)ᵀ = η` + (`Photon.JetAlgebra.lorentzAction_maxwellTerm`), the mass term because the + spinor representation preserves `γ⁰` + (`spinorRep_conjTranspose_gammaZero_spinorRep`), and the kinetic term by + the contraction identity; +* the Lagrangian, being built from invariant pieces, is invariant + (`lorentzAction_lagrangian`). + +This file contains no definitions, only theorems about the jet algebras of +`Physlib.Particles.QED.Basic`, the fields of `Physlib.Particles.QED.Fields` and the Lagrangian of +`Physlib.Particles.QED.Lagrangian`. + +## ii. Key results + +- `sum_kineticGamma_contraction` : the Lorentz contraction identity of the + matrices `γ⁰ γ^μ` under the spinor representation. +- `spinorRep_conjTranspose_gammaZero_spinorRep` : the spinor representation + preserves `γ⁰`. +- `JetAlgebra.lorentzAction_A_zero`, `JetAlgebra.lorentzAction_ψ_zero`, + `JetAlgebra.lorentzAction_ψ_singleton`, … : the transformation laws of the + jet coordinates. +- `JetAlgebra.lorentzAction_covDψ` : Lorentz covariance of the covariant + derivative. +- `Photon.JetAlgebra.lorentzAction_maxwellTerm`, + `JetAlgebra.lorentzAction_maxwellTerm` : Lorentz invariance of the Maxwell + term. +- `JetAlgebra.lorentzAction_electronMassTerm`, + `JetAlgebra.lorentzAction_diracKineticTerm` : Lorentz invariance of the + fermionic terms. +- `JetAlgebra.lorentzAction_lagrangian` : **Lorentz invariance of the QED + Lagrangian**. + +## iii. Table of contents + +- A. Contractions of the Minkowski metric with a Lorentz transformation +- B. The intertwining identities of the spinor representation + - B.1. Conjugation of the covariant Pauli matrices + - B.2. The two block identities + - B.3. The contraction identity of the kinetic matrices + - B.4. The spinor representation preserves `γ⁰` +- C. The transformation laws of the jet coordinates +- D. Lorentz invariance of the Maxwell term +- E. Lorentz covariance of the covariant derivative +- F. Lorentz invariance of the fermionic terms +- G. Lorentz invariance of the QED Lagrangian + +## iv. References + +The Lorentz actions are defined in `Physlib.Particles.QED.Basic`; the corresponding +machinery for the lepton–gauge sector is +`Physlib.Particles.LeptonGaugeSector.JetAlgebra.LorentzAction`. + +-/ + +@[expose] public section + +namespace QED + +open Matrix MatrixGroups minkowskiMatrix TensorProduct +open scoped PauliMatrix + +attribute [-simp] Fintype.sum_sum_type + +/-! + +## A. Contractions of the Minkowski metric with a Lorentz transformation + +-/ + +/-- The defining property of the Lorentz group in index form: contracting two + rows of `Λ⁻¹` with the Minkowski metric reproduces the metric. -/ +lemma sum_eta_inv_inv (Λ : LorentzGroup 3) (τ τ' : Fin 1 ⊕ Fin 3) : + ∑ μ, η μ μ * ((Λ⁻¹).1 τ μ * (Λ⁻¹).1 τ' μ) = η τ τ' := by + have h := congrArg (fun A : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) ℝ => A τ τ') + (LorentzGroup.mul_minkowskiMatrix_mul_transpose (Λ := Λ⁻¹)) + simp only [Matrix.mul_apply, Matrix.transpose_apply] at h + rw [← h] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [Finset.sum_eq_single μ (fun a _ ha => by rw [off_diag_zero ha, mul_zero]) + (fun h => absurd (Finset.mem_univ μ) h)] + ring + +/-! + +## B. The intertwining identities of the spinor representation + +### B.1. Conjugation of the covariant Pauli matrices + +-/ + +/-- The covariant Pauli matrices are `σ̄^μ = η_{μμ} σ^μ` (no sum). -/ +lemma pauliSelfAdjoint'_coe (μ : Fin 1 ⊕ Fin 3) : + (PauliMatrix.pauliSelfAdjoint' μ).1 = η μ μ • σ μ := by + fin_cases μ <;> simp [PauliMatrix.pauliSelfAdjoint'] + +/-- The kinetic matrices through the covariant Pauli matrices: + `γ⁰ γ^μ = ((σ̄^μ, 0), (0, η_{μμ} σ̄^μ))`. -/ +lemma kineticGamma_eq_fromBlocks_pauliSelfAdjoint' (μ : Fin 1 ⊕ Fin 3) : + JetAlgebra.kineticGamma μ = + Matrix.fromBlocks (PauliMatrix.pauliSelfAdjoint' μ).1 0 0 + (η μ μ • (PauliMatrix.pauliSelfAdjoint' μ).1) := by + rw [JetAlgebra.kineticGamma, pauliSelfAdjoint'_coe, smul_smul, + minkowskiMatrix.η_apply_mul_η_apply_diag, one_smul] + +/-- Conjugating a covariant Pauli matrix by `N : SL(2,ℂ)` transforms its + index by the image of `N` in the Lorentz group; this is the defining + property of the covering map. -/ +lemma sl2c_conj_pauliSelfAdjoint' (N : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + N.1 * (PauliMatrix.pauliSelfAdjoint' μ).1 * N.1ᴴ = + ∑ ν, (Lorentz.SL2C.toLorentzGroup N).1 ν μ • + (PauliMatrix.pauliSelfAdjoint' ν).1 := by + have h := congrArg Subtype.val (Lorentz.SL2C.toSelfAdjointMap_basis (M := N) μ) + simpa only [Lorentz.SL2C.toSelfAdjointMap_apply_coe, PauliMatrix.pauliBasis', + Module.Basis.coe_mk, AddSubmonoidClass.coe_finsetSum, selfAdjoint.val_smul] using h + +/-- A block matrix summed over the diagonal blocks. -/ +lemma sum_fromBlocks {ι : Type*} (s : Finset ι) + (A : ι → Matrix (Fin 2) (Fin 2) ℂ) (D : ι → Matrix (Fin 2) (Fin 2) ℂ) : + ∑ i ∈ s, Matrix.fromBlocks (A i) 0 0 (D i) = + Matrix.fromBlocks (∑ i ∈ s, A i) 0 0 (∑ i ∈ s, D i) := by + induction s using Finset.cons_induction with + | empty => simp + | cons a s ha ih => + rw [Finset.sum_cons, Finset.sum_cons, Finset.sum_cons, ih, + Matrix.fromBlocks_add, add_zero] + +/-! + +### B.2. The two block identities + +The left Weyl block: transporting the index of `σ̄^μ` with `Λ(M)⁻¹` cancels +the conjugation by `M`, through `Λ(M†) = Λ(M)ᵀ`. + +-/ + +lemma sum_lorentz_inv_conjTranspose_pauli_conj (M : SL(2,ℂ)) (τ : Fin 1 ⊕ Fin 3) : + ∑ μ, ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ • + (M.1ᴴ * (PauliMatrix.pauliSelfAdjoint' μ).1 * M.1) = + (PauliMatrix.pauliSelfAdjoint' τ).1 := by + have hdet : Matrix.det (M.1ᴴ) = 1 := by + rw [Matrix.det_conjTranspose, Matrix.SpecialLinearGroup.det_coe] + exact star_one ℂ + have hswap : ∀ μ, M.1ᴴ * (PauliMatrix.pauliSelfAdjoint' μ).1 * M.1 = + ∑ ν, (Lorentz.SL2C.toLorentzGroup M).1 μ ν • + (PauliMatrix.pauliSelfAdjoint' ν).1 := by + intro μ + have h := sl2c_conj_pauliSelfAdjoint' ⟨M.1ᴴ, hdet⟩ μ + rw [show ((⟨M.1ᴴ, hdet⟩ : SL(2,ℂ)) : Matrix (Fin 2) (Fin 2) ℂ)ᴴ = M.1 from + Matrix.conjTranspose_conjTranspose _] at h + rw [show ((⟨M.1ᴴ, hdet⟩ : SL(2,ℂ)) : Matrix (Fin 2) (Fin 2) ℂ) = M.1ᴴ from rfl] at h + rw [h] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [Lorentz.SL2C.toLorentzGroup_conjTranspose (M := M) rfl, Matrix.transpose_apply] + rw [Finset.sum_congr rfl fun μ _ => by rw [hswap μ, Finset.smul_sum], Finset.sum_comm] + rw [Finset.sum_congr rfl fun ν _ => show + (∑ μ, ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ • + ((Lorentz.SL2C.toLorentzGroup M).1 μ ν • (PauliMatrix.pauliSelfAdjoint' ν).1)) = + ((1 : Matrix (Fin 1 ⊕ Fin 3) (Fin 1 ⊕ Fin 3) ℝ) τ ν) • + (PauliMatrix.pauliSelfAdjoint' ν).1 from by + rw [Finset.sum_congr rfl fun μ _ => smul_smul (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ) + ((Lorentz.SL2C.toLorentzGroup M).1 μ ν) (PauliMatrix.pauliSelfAdjoint' ν).1, + ← Finset.sum_smul, ← Matrix.mul_apply, ← lorentzGroupIsGroup_mul_coe, + inv_mul_cancel, lorentzGroupIsGroup_one_coe]] + rw [Finset.sum_eq_single τ + (fun ν _ hν => by rw [Matrix.one_apply_ne (Ne.symm hν), zero_smul]) + (fun h => absurd (Finset.mem_univ τ) h), Matrix.one_apply_eq, one_smul] + +/-- The right Weyl block: transporting the index of `η_{μμ} σ̄^μ` with + `Λ(M)⁻¹` cancels the conjugation by `(M⁻¹)†`, through `Λ⁻¹ η (Λ⁻¹)ᵀ = η`. -/ +lemma sum_lorentz_inv_eta_pauli_conj (M : SL(2,ℂ)) (τ : Fin 1 ⊕ Fin 3) : + ∑ μ, (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ * η μ μ) • + ((M⁻¹).1 * (PauliMatrix.pauliSelfAdjoint' μ).1 * ((M⁻¹).1)ᴴ) = + η τ τ • (PauliMatrix.pauliSelfAdjoint' τ).1 := by + have hswap : ∀ μ, (M⁻¹).1 * (PauliMatrix.pauliSelfAdjoint' μ).1 * ((M⁻¹).1)ᴴ = + ∑ ν, ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ • + (PauliMatrix.pauliSelfAdjoint' ν).1 := by + intro μ + rw [sl2c_conj_pauliSelfAdjoint' M⁻¹ μ] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_inv] + rw [Finset.sum_congr rfl fun μ _ => by rw [hswap μ, Finset.smul_sum], Finset.sum_comm] + rw [Finset.sum_congr rfl fun ν _ => show + (∑ μ, (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ * η μ μ) • + (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ • (PauliMatrix.pauliSelfAdjoint' ν).1)) = + (η τ ν) • (PauliMatrix.pauliSelfAdjoint' ν).1 from by + rw [Finset.sum_congr rfl fun μ _ => + smul_smul ((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ * η μ μ)) + (((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ) (PauliMatrix.pauliSelfAdjoint' ν).1, + ← Finset.sum_smul, + show (∑ μ, ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ * η μ μ * + ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ) = η τ ν from by + rw [← sum_eta_inv_inv (Lorentz.SL2C.toLorentzGroup M) τ ν] + exact Finset.sum_congr rfl fun μ _ => by ring]] + rw [Finset.sum_eq_single τ + (fun ν _ hν => by rw [off_diag_zero (Ne.symm hν), zero_smul]) + (fun h => absurd (Finset.mem_univ τ) h)] + +/-! + +### B.3. The contraction identity of the kinetic matrices + +-/ + +/-- The matrix form of the contraction identity: transporting the vector index + of `γ⁰ γ^μ` with `Λ(M)⁻¹` cancels the conjugation by the spinor + representation. -/ +lemma sum_lorentz_inv_spinorRep_kineticGamma (M : SL(2,ℂ)) (τ : Fin 1 ⊕ Fin 3) : + ∑ μ, ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ • + ((Electron.JetAlgebra.spinorRep M)ᴴ * JetAlgebra.kineticGamma μ * + Electron.JetAlgebra.spinorRep M) = + JetAlgebra.kineticGamma τ := by + have hS : (Electron.JetAlgebra.spinorRep M)ᴴ = + Matrix.fromBlocks M.1ᴴ 0 0 ((M⁻¹).1) := by + rw [Electron.JetAlgebra.spinorRep, Matrix.fromBlocks_conjTranspose] + simp + have hblock : ∀ μ, (Electron.JetAlgebra.spinorRep M)ᴴ * JetAlgebra.kineticGamma μ * + Electron.JetAlgebra.spinorRep M = + Matrix.fromBlocks (M.1ᴴ * (PauliMatrix.pauliSelfAdjoint' μ).1 * M.1) 0 0 + (η μ μ • ((M⁻¹).1 * (PauliMatrix.pauliSelfAdjoint' μ).1 * ((M⁻¹).1)ᴴ)) := by + intro μ + rw [hS, Electron.JetAlgebra.spinorRep, kineticGamma_eq_fromBlocks_pauliSelfAdjoint', + Matrix.fromBlocks_multiply, Matrix.fromBlocks_multiply] + congr 1 <;> simp + rw [Finset.sum_congr rfl fun μ _ => by + rw [hblock μ, Matrix.fromBlocks_smul, smul_zero, smul_smul]] + rw [sum_fromBlocks, sum_lorentz_inv_conjTranspose_pauli_conj, + sum_lorentz_inv_eta_pauli_conj, kineticGamma_eq_fromBlocks_pauliSelfAdjoint'] + +/-- **The contraction identity of the Dirac kinetic term**: the index form of + `∑_μ (Λ⁻¹)_{τμ} S(M)† (γ⁰ γ^μ) S(M) = γ⁰ γ^τ`. This is the identity that + makes `i ψ̄ γ^μ D_μ ψ` a Lorentz scalar. -/ +lemma sum_kineticGamma_contraction (M : SL(2,ℂ)) (τ : Fin 1 ⊕ Fin 3) + (α' β' : Fin 2 ⊕ Fin 2) : + ∑ μ, ∑ α, ∑ β, JetAlgebra.kineticGamma μ α β * + (star (Electron.JetAlgebra.spinorRep M α α') * + (((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ : ℝ) : ℂ) * + Electron.JetAlgebra.spinorRep M β β')) = + JetAlgebra.kineticGamma τ α' β' := by + have h := congrArg (fun A : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ => A α' β') + (sum_lorentz_inv_spinorRep_kineticGamma M τ) + simp only [Matrix.sum_apply, Matrix.smul_apply, Matrix.mul_apply, + Matrix.conjTranspose_apply, Complex.real_smul] at h + rw [← h] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [Finset.mul_sum, Finset.sum_comm] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [Finset.sum_mul, Finset.mul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + ring + +/-! + +### B.4. The spinor representation preserves `γ⁰` + +-/ + +/-- The spinor representation preserves `γ⁰`: `S(M)† γ⁰ S(M) = γ⁰`. This is + the identity that makes the Dirac mass term `m ψ̄ ψ` a Lorentz scalar. -/ +lemma spinorRep_conjTranspose_gammaZero_spinorRep (M : SL(2,ℂ)) : + (Electron.JetAlgebra.spinorRep M)ᴴ * JetAlgebra.gammaMatrix (Sum.inl 0) * + Electron.JetAlgebra.spinorRep M = JetAlgebra.gammaMatrix (Sum.inl 0) := by + have h1 : M.1ᴴ * ((M⁻¹).1)ᴴ = 1 := by + rw [← Matrix.conjTranspose_mul, ← Matrix.SpecialLinearGroup.coe_mul, + inv_mul_cancel, Matrix.SpecialLinearGroup.coe_one, Matrix.conjTranspose_one] + have h2 : (M⁻¹).1 * M.1 = 1 := by + rw [← Matrix.SpecialLinearGroup.coe_mul, inv_mul_cancel, + Matrix.SpecialLinearGroup.coe_one] + rw [Electron.JetAlgebra.spinorRep, JetAlgebra.gammaMatrix_inl_zero, + Matrix.fromBlocks_conjTranspose, Matrix.fromBlocks_multiply, + Matrix.fromBlocks_multiply] + simp only [Matrix.conjTranspose_zero, Matrix.conjTranspose_conjTranspose, + Matrix.mul_zero, Matrix.zero_mul, Matrix.mul_one, add_zero, + zero_add] + rw [h1, h2] + +/-- The index form of `S(M)† γ⁰ S(M) = γ⁰`. -/ +lemma sum_gammaZero_contraction (M : SL(2,ℂ)) (α' β' : Fin 2 ⊕ Fin 2) : + ∑ α, ∑ β, JetAlgebra.gammaMatrix (Sum.inl 0) α β * + (star (Electron.JetAlgebra.spinorRep M α α') * + Electron.JetAlgebra.spinorRep M β β') = + JetAlgebra.gammaMatrix (Sum.inl 0) α' β' := by + have h := congrArg (fun A : Matrix (Fin 2 ⊕ Fin 2) (Fin 2 ⊕ Fin 2) ℂ => A α' β') + (spinorRep_conjTranspose_gammaZero_spinorRep M) + simp only [Matrix.mul_apply, Matrix.conjTranspose_apply] at h + rw [← h, Finset.sum_comm] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [Finset.sum_mul] + refine Finset.sum_congr rfl fun α _ => ?_ + ring + +/-! + +## C. The transformation laws of the jet coordinates + +-/ + +namespace JetAlgebra + +/-- The photon jet coordinate transforms as a covector. -/ +theorem lorentzAction_A_zero (M : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + lorentzAction M (A 0 μ) = + ∑ ν, ((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ : ℝ) : ℂ) • A 0 ν := by + simp only [A] + rw [lorentzAction_tmul, map_one, lorentzActionPhoton_tmul, + Photon.JetAlgebra.lorentzAction_coord_zero, TensorProduct.tmul_sum, sum_tmul] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [TensorProduct.tmul_smul, real_smul_tmul] + +/-- The first-order photon jet coordinate transforms as a two-tensor. -/ +theorem lorentzAction_A_singleton (M : SL(2,ℂ)) (ρ μ : Fin 1 ⊕ Fin 3) : + lorentzAction M (A {ρ} μ) = + ∑ τ, ∑ ν, ((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ ρ * + ((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 ν μ : ℝ) : ℂ) • A {τ} ν := by + simp only [A] + rw [lorentzAction_tmul, map_one, lorentzActionPhoton_tmul, + Photon.JetAlgebra.lorentzAction_coord_singleton] + rw [TensorProduct.tmul_sum, sum_tmul] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [TensorProduct.tmul_sum, sum_tmul] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [TensorProduct.tmul_smul, real_smul_tmul] + +/-- The electron jet coordinate transforms in the spinor representation. -/ +theorem lorentzAction_ψ_zero (M : SL(2,ℂ)) (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ψ 0 α) = + ∑ β, Electron.JetAlgebra.spinorRep M α β • ψ 0 β := by + simp only [ψ] + rw [lorentzAction_tmul, map_one, + Electron.JetAlgebra.lorentzAction_ofGenerator_dψ_zero, tmul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [tmul_smul] + +/-- The conjugate electron jet coordinate transforms in the conjugate spinor + representation. -/ +theorem lorentzAction_barψ_zero (M : SL(2,ℂ)) (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (barψ 0 α) = + ∑ β, star (Electron.JetAlgebra.spinorRep M α β) • barψ 0 β := by + simp only [barψ] + rw [lorentzAction_tmul, map_one, + Electron.JetAlgebra.lorentzAction_ofGenerator_dbarψ_zero, tmul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [tmul_smul] + +/-- The first-order electron jet coordinate transforms as a spinor with a + covector derivative index. -/ +theorem lorentzAction_ψ_singleton (M : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (ψ {ρ} α) = + ∑ τ, ∑ β, (((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ ρ : ℝ) : ℂ) * + Electron.JetAlgebra.spinorRep M α β) • ψ {τ} β := by + simp only [ψ] + rw [lorentzAction_tmul, map_one, + Electron.JetAlgebra.lorentzAction_ofGenerator_dψ_singleton, tmul_sum] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [tmul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [tmul_smul, Complex.real_smul] + +theorem lorentzAction_barψ_singleton (M : SL(2,ℂ)) (ρ : Fin 1 ⊕ Fin 3) + (α : Fin 2 ⊕ Fin 2) : + lorentzAction M (barψ {ρ} α) = + ∑ τ, ∑ β, (((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ ρ : ℝ) : ℂ) * + star (Electron.JetAlgebra.spinorRep M α β)) • barψ {τ} β := by + simp only [barψ] + rw [lorentzAction_tmul, map_one, + Electron.JetAlgebra.lorentzAction_ofGenerator_dbarψ_singleton, tmul_sum] + refine Finset.sum_congr rfl fun τ _ => ?_ + rw [tmul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [tmul_smul, Complex.real_smul] + +end JetAlgebra + +/-! + +## D. Lorentz invariance of the Maxwell term + +-/ + +namespace Photon + +namespace JetAlgebra + +/-- The formal field strength transforms as an antisymmetric two-tensor. -/ +lemma lorentzAction_fieldStrength_zero (Λ : LorentzGroup 3) (μ ν : Fin 1 ⊕ Fin 3) : + lorentzAction Λ (fieldStrength 0 μ ν) = + ∑ a, ∑ b, ((Λ⁻¹).1 a μ * (Λ⁻¹).1 b ν) • fieldStrength 0 a b := by + rw [fieldStrength, zero_add, zero_add, map_sub, lorentzAction_coord_singleton, + lorentzAction_coord_singleton, + Finset.sum_comm (f := fun a b => ((Λ⁻¹).1 a ν * (Λ⁻¹).1 b μ) • coord {a} b), + ← Finset.sum_sub_distrib] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [← Finset.sum_sub_distrib] + refine Finset.sum_congr rfl fun b _ => ?_ + rw [fieldStrength, zero_add, zero_add, smul_sub] + congr 1 + rw [mul_comm] + +set_option maxHeartbeats 4000000 in +/-- **Lorentz invariance of the Maxwell term** in the photon jet algebra: + the two metric contractions absorb the four transformation matrices through + `Λ⁻¹ η (Λ⁻¹)ᵀ = η`. -/ +theorem lorentzAction_maxwellTerm (Λ : LorentzGroup 3) : + lorentzAction Λ maxwellTerm = maxwellTerm := by + have hcoef : ∀ a b c d : Fin 1 ⊕ Fin 3, + (∑ μ, ∑ ν, (η μ μ * η ν ν) * + ((Λ⁻¹).1 c μ * (Λ⁻¹).1 d ν * ((Λ⁻¹).1 a μ * (Λ⁻¹).1 b ν))) = + η c a * η d b := by + intro a b c d + calc (∑ μ, ∑ ν, (η μ μ * η ν ν) * + ((Λ⁻¹).1 c μ * (Λ⁻¹).1 d ν * ((Λ⁻¹).1 a μ * (Λ⁻¹).1 b ν))) + = ∑ μ, ∑ ν, (η μ μ * ((Λ⁻¹).1 c μ * (Λ⁻¹).1 a μ)) * + (η ν ν * ((Λ⁻¹).1 d ν * (Λ⁻¹).1 b ν)) := by + refine Finset.sum_congr rfl fun μ _ => Finset.sum_congr rfl fun ν _ => ?_ + ring + _ = (∑ μ, η μ μ * ((Λ⁻¹).1 c μ * (Λ⁻¹).1 a μ)) * + (∑ ν, η ν ν * ((Λ⁻¹).1 d ν * (Λ⁻¹).1 b ν)) := by + rw [Finset.sum_mul_sum] + _ = η c a * η d b := by rw [sum_eta_inv_inv, sum_eta_inv_inv] + have hinner : ∀ a b c d : Fin 1 ⊕ Fin 3, + (∑ μ, ∑ ν, ((η μ μ * η ν ν) * + ((Λ⁻¹).1 c μ * (Λ⁻¹).1 d ν * ((Λ⁻¹).1 a μ * (Λ⁻¹).1 b ν))) • + (fieldStrength 0 c d * fieldStrength 0 a b)) = + (η c a * η d b) • (fieldStrength 0 c d * fieldStrength 0 a b) := by + intro a b c d + rw [← hcoef a b c d, Finset.sum_smul] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [Finset.sum_smul] + rw [maxwellTerm, map_sum] + conv_lhs => enter [2, μ]; rw [map_sum] + conv_lhs => + enter [2, μ, 2, ν] + rw [map_smul, map_mul, lorentzAction_fieldStrength_zero] + simp only [Finset.sum_mul, Finset.mul_sum, smul_mul_smul_comm, Finset.smul_sum, + smul_smul] + -- reorder the six sums from `μ ν a b c d` to `a b c d μ ν` + conv_lhs => enter [2, μ]; rw [Finset.sum_comm] + conv_lhs => enter [2, μ, 2, a]; rw [Finset.sum_comm] + conv_lhs => enter [2, μ, 2, a, 2, b]; rw [Finset.sum_comm] + conv_lhs => enter [2, μ, 2, a, 2, b, 2, c]; rw [Finset.sum_comm] + conv_lhs => rw [Finset.sum_comm] + conv_lhs => enter [2, a]; rw [Finset.sum_comm] + conv_lhs => enter [2, a, 2, b]; rw [Finset.sum_comm] + conv_lhs => enter [2, a, 2, b, 2, c]; rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun b _ => ?_ + calc (∑ c, ∑ d, ∑ μ, ∑ ν, ((η μ μ * η ν ν) * + ((Λ⁻¹).1 c μ * (Λ⁻¹).1 d ν * ((Λ⁻¹).1 a μ * (Λ⁻¹).1 b ν))) • + (fieldStrength 0 c d * fieldStrength 0 a b)) + = ∑ c, ∑ d, (η c a * η d b) • (fieldStrength 0 c d * fieldStrength 0 a b) := + Finset.sum_congr rfl fun c _ => Finset.sum_congr rfl fun d _ => hinner a b c d + _ = (η a a * η b b) • (fieldStrength 0 a b * fieldStrength 0 a b) := by + rw [Finset.sum_eq_single a (fun c _ hc => Finset.sum_eq_zero fun d _ => by + rw [off_diag_zero hc, zero_mul, zero_smul]) + (fun h => absurd (Finset.mem_univ a) h), + Finset.sum_eq_single b (fun d _ hd => by + rw [off_diag_zero hd, mul_zero, zero_smul]) + (fun h => absurd (Finset.mem_univ b) h)] + +end JetAlgebra + +end Photon + +namespace JetAlgebra + +/-- **Lorentz invariance of the Maxwell term** in the QED jet algebra, + inherited from the photon jet algebra. -/ +theorem lorentzAction_maxwellTerm (M : SL(2,ℂ)) : + lorentzAction M maxwellTerm = maxwellTerm := by + simp only [maxwellTerm] + rw [lorentzAction_tmul, map_one, lorentzActionPhoton_tmul, + Photon.JetAlgebra.lorentzAction_maxwellTerm] + +/-! + +## E. Lorentz covariance of the covariant derivative + +-/ + +/-- The covariant derivative transforms exactly like the first-order jet + coordinate: as a spinor with a covector derivative index. -/ +theorem lorentzAction_covDψ (M : SL(2,ℂ)) (e : ℝ) (μ : Fin 1 ⊕ Fin 3) + (β : Fin 2 ⊕ Fin 2) : + lorentzAction M (covDψ e μ β) = + ∑ τ, ∑ β', (((((Lorentz.SL2C.toLorentzGroup M)⁻¹).1 τ μ : ℝ) : ℂ) * + Electron.JetAlgebra.spinorRep M β β') • covDψ e τ β' := by + rw [covDψ, map_add, map_smul, map_mul, lorentzAction_ψ_singleton, + lorentzAction_A_zero, lorentzAction_ψ_zero, Finset.sum_mul_sum] + simp only [smul_mul_smul_comm, Finset.smul_sum, smul_smul, smul_add, + Finset.sum_add_distrib, covDψ] + congr 1 + all_goals + refine Finset.sum_congr rfl fun τ _ => Finset.sum_congr rfl fun β' _ => ?_ + first + | rfl + | exact congrArg (· • _) (by ring) + +/-! + +## F. Lorentz invariance of the fermionic terms + +-/ + +set_option maxHeartbeats 2000000 in +/-- **Lorentz invariance of the Dirac mass term**: the spinor phases of the + electron and its conjugate cancel through `S(M)† γ⁰ S(M) = γ⁰`. -/ +theorem lorentzAction_electronMassTerm (M : SL(2,ℂ)) : + lorentzAction M electronMassTerm = electronMassTerm := by + rw [electronMassTerm, map_sum] + conv_lhs => enter [2, α]; rw [map_sum] + conv_lhs => + enter [2, α, 2, β] + rw [map_smul, map_mul, lorentzAction_barψ_zero, lorentzAction_ψ_zero] + simp only [Finset.sum_mul, Finset.mul_sum, smul_mul_smul_comm, Finset.smul_sum, + smul_smul] + -- reorder the four sums from `α β β' α'` to `α' β' α β` + conv_lhs => enter [2, α, 2, β]; rw [Finset.sum_comm] + conv_lhs => enter [2, α]; rw [Finset.sum_comm] + conv_lhs => rw [Finset.sum_comm] + conv_lhs => enter [2, α', 2, α]; rw [Finset.sum_comm] + conv_lhs => enter [2, α']; rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun α' _ => Finset.sum_congr rfl fun β' _ => ?_ + rw [← sum_gammaZero_contraction M α' β', Finset.sum_smul] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [Finset.sum_smul] + +set_option maxHeartbeats 2000000 in +/-- **Lorentz invariance of the Dirac kinetic term**: the transformation of + the two spinor slots and the derivative slot cancels through the contraction + identity of the matrices `γ⁰ γ^μ`. -/ +theorem lorentzAction_diracKineticTerm (M : SL(2,ℂ)) (e : ℝ) : + lorentzAction M (diracKineticTerm e) = diracKineticTerm e := by + rw [diracKineticTerm, map_smul, map_sum] + congr 1 + conv_lhs => enter [2, μ]; rw [map_sum] + conv_lhs => enter [2, μ, 2, α]; rw [map_sum] + conv_lhs => + enter [2, μ, 2, α, 2, β] + rw [map_smul, map_mul, lorentzAction_barψ_zero, lorentzAction_covDψ] + simp only [Finset.sum_mul, Finset.mul_sum, smul_mul_smul_comm, Finset.smul_sum, + smul_smul] + -- reorder the six sums from `μ α β τ β' α'` to `τ α' β' μ α β` + conv_lhs => enter [2, μ, 2, α]; rw [Finset.sum_comm] + conv_lhs => enter [2, μ]; rw [Finset.sum_comm] + conv_lhs => rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, μ, 2, α, 2, β]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, μ, 2, α]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, μ]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, α', 2, μ, 2, α]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, α', 2, μ]; rw [Finset.sum_comm] + conv_lhs => enter [2, τ, 2, α']; rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun τ _ => Finset.sum_congr rfl fun α' _ => + Finset.sum_congr rfl fun β' _ => ?_ + rw [← sum_kineticGamma_contraction M τ α' β', Finset.sum_smul] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [Finset.sum_smul] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [Finset.sum_smul] + +/-! + +## G. Lorentz invariance of the QED Lagrangian + +-/ + +/-- **Lorentz invariance of the QED Lagrangian.** The Maxwell term is + invariant through `Λ⁻¹ η (Λ⁻¹)ᵀ = η`, the kinetic term through the + contraction identity of `γ⁰ γ^μ` under the spinor representation, and the + mass term through `S(M)† γ⁰ S(M) = γ⁰`. -/ +theorem lorentzAction_lagrangian (M : SL(2,ℂ)) (e m : ℝ) : + lorentzAction M (lagrangian e m) = lagrangian e m := by + rw [lagrangian, map_sub, map_add, map_smul, map_smul, lorentzAction_maxwellTerm, + lorentzAction_diracKineticTerm, lorentzAction_electronMassTerm] + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/QED/MassDimension.lean b/Physlib/Particles/QED/MassDimension.lean new file mode 100644 index 000000000..61b130618 --- /dev/null +++ b/Physlib/Particles/QED/MassDimension.lean @@ -0,0 +1,254 @@ +/- +Copyright (c) 2026 Jinzheng Li. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li +-/ +module + +public import Physlib.Particles.QED.Lagrangian +public import Physlib.Particles.QED.FieldStrength +public import Mathlib.Tactic.Module +/-! +# Mass dimensions in quantum electrodynamics + +## i. Overview + +The mass-dimension bookkeeping of QED, through the mass-weight scaling of +`Physlib.Particles.QED.Basic` (the algebra map multiplying each jet coordinate by `c` +to twice its mass dimension): the photon has dimension one, the electron +`3/2`, and each derivative adds one. The theorems of this file identify the +composite fields and the terms of the Lagrangian as eigenvectors of the +scaling: + +* the covariant derivative `D_μ ψ` is homogeneous of weight five — this is + the statement that the electric coupling `e` is dimensionless, which is + what makes QED renormalizable; +* the Maxwell term and the Dirac kinetic term have weight eight (mass + dimension four), and the mass term weight six (dimension three); +* consequently `L(e, c² m)` scales to `c⁸ L(e, m)`: the Lagrangian has mass + dimension four with the electron mass a coefficient of dimension one. + +This file contains no definitions, only theorems. + +## ii. Key results + +- `JetAlgebra.massScale_A_zero`, `JetAlgebra.massScale_ψ`, … : the scaling of + the jet coordinates. +- `JetAlgebra.massScale_covDψ` : the covariant derivative is homogeneous of + weight five; the coupling is dimensionless. +- `JetAlgebra.massScale_maxwellTerm`, `JetAlgebra.massScale_diracKineticTerm`, + `JetAlgebra.massScale_electronMassTerm` : the weights of the terms. +- `JetAlgebra.massScale_lagrangian` : **the QED Lagrangian has mass dimension + four**. + +## iii. Table of contents + +- A. The scaling of the jet coordinates +- B. Homogeneity of the field strength and the covariant derivative +- C. The weights of the terms of the Lagrangian +- D. The mass dimension of the QED Lagrangian + +## iv. References + +The scaling maps are defined in `Physlib.Particles.QED.Basic`; the corresponding +grading for the lepton–gauge sector is +`Physlib.Particles.LeptonGaugeSector.JetAlgebra.MassDim`. + +-/ + +@[expose] public section + +/-! TODO: Upgrade the mass-weight scaling to a genuine filtration by submodules, following -/ +/-! TODO: `LeptonGaugeSector.JetAlgebra.MassDim` (`MassWeightLESubmodule`), together with the -/ +/-! TODO: derivative-order and fermion-parity gradings needed for classification arguments. -/ + +namespace QED + +open TensorProduct + +namespace Photon + +namespace JetAlgebra + +/-! + +## A. The scaling of the jet coordinates + +The photon-level scaling of the field strength and the Maxwell term, used to +lift the weight of the Maxwell term to the QED jet algebra. + +-/ + +/-- The photon-level field strength has mass dimension two. -/ +lemma massScale_fieldStrength_zero (c : ℝ) (μ ν : Fin 1 ⊕ Fin 3) : + massScale c (fieldStrength 0 μ ν) = c ^ 4 • fieldStrength 0 μ ν := by + rw [fieldStrength, zero_add, zero_add, map_sub, massScale_coord, massScale_coord, + smul_sub] + norm_num + +/-- The photon-level Maxwell term has mass dimension four. -/ +theorem massScale_maxwellTerm (c : ℝ) : + massScale c maxwellTerm = c ^ 8 • maxwellTerm := by + rw [maxwellTerm, map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_smul, map_mul, massScale_fieldStrength_zero, smul_mul_smul_comm, + ← pow_add, smul_comm] + +end JetAlgebra + +end Photon + +namespace JetAlgebra + +theorem massScale_A (c : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + massScale c (A s μ) = (c : ℂ) ^ (2 + 2 * Multiset.card s) • A s μ := by + simp only [A] + rw [massScale_tmul, map_one, massScalePhoton_tmul, + Photon.JetAlgebra.massScale_coord, TensorProduct.tmul_smul, real_smul_tmul, + Complex.ofReal_pow] + +theorem massScale_ψ (c : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + massScale c (ψ s α) = (c : ℂ) ^ (3 + 2 * Multiset.card s) • ψ s α := by + simp only [ψ] + rw [massScale_tmul, map_one, Electron.JetAlgebra.massScale_ofGenerator, tmul_smul] + rfl + +theorem massScale_barψ (c : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2 ⊕ Fin 2) : + massScale c (barψ s α) = (c : ℂ) ^ (3 + 2 * Multiset.card s) • barψ s α := by + simp only [barψ] + rw [massScale_tmul, map_one, Electron.JetAlgebra.massScale_ofGenerator, tmul_smul] + rfl + +/-- The photon jet coordinate has mass dimension one. -/ +theorem massScale_A_zero (c : ℝ) (μ : Fin 1 ⊕ Fin 3) : + massScale c (A 0 μ) = (c : ℂ) ^ 2 • A 0 μ := by + rw [massScale_A] + norm_num + +/-- The electron jet coordinate has mass dimension `3/2`. -/ +theorem massScale_ψ_zero (c : ℝ) (α : Fin 2 ⊕ Fin 2) : + massScale c (ψ 0 α) = (c : ℂ) ^ 3 • ψ 0 α := by + rw [massScale_ψ] + norm_num + +theorem massScale_barψ_zero (c : ℝ) (α : Fin 2 ⊕ Fin 2) : + massScale c (barψ 0 α) = (c : ℂ) ^ 3 • barψ 0 α := by + rw [massScale_barψ] + norm_num + +theorem massScale_ψ_singleton (c : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + massScale c (ψ {μ} α) = (c : ℂ) ^ 5 • ψ {μ} α := by + rw [massScale_ψ] + norm_num + +theorem massScale_barψ_singleton (c : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + massScale c (barψ {μ} α) = (c : ℂ) ^ 5 • barψ {μ} α := by + rw [massScale_barψ] + norm_num + +/-! + +## B. Homogeneity of the field strength and the covariant derivative + +-/ + +/-- The field strength has mass dimension two. -/ +theorem massScale_fieldStrength_zero (c : ℝ) (μ ν : Fin 1 ⊕ Fin 3) : + massScale c (fieldStrength 0 μ ν) = (c : ℂ) ^ 4 • fieldStrength 0 μ ν := by + rw [fieldStrength_eq_sub, map_sub, massScale_A, massScale_A, smul_sub] + norm_num + +/-- **The covariant derivative is homogeneous**, of the same weight as the + plain derivative: the electric coupling `e` is dimensionless. This is the + power-counting statement behind the renormalizability of QED. -/ +theorem massScale_covDψ (c : ℝ) (e : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + massScale c (covDψ e μ α) = (c : ℂ) ^ 5 • covDψ e μ α := by + rw [covDψ, map_add, map_smul, map_mul, massScale_ψ_singleton, massScale_A_zero, + massScale_ψ_zero] + simp only [smul_mul_smul_comm, smul_add, smul_smul] + module + +theorem massScale_covDbarψ (c : ℝ) (e : ℝ) (μ : Fin 1 ⊕ Fin 3) (α : Fin 2 ⊕ Fin 2) : + massScale c (covDbarψ e μ α) = (c : ℂ) ^ 5 • covDbarψ e μ α := by + rw [covDbarψ, map_sub, map_smul, map_mul, massScale_barψ_singleton, + massScale_A_zero, massScale_barψ_zero] + simp only [smul_mul_smul_comm, smul_sub, smul_smul] + module + +/-! + +## C. The weights of the terms of the Lagrangian + +-/ + +/-- The Maxwell term has mass dimension four. -/ +theorem massScale_maxwellTerm (c : ℝ) : + massScale c maxwellTerm = (c : ℂ) ^ 8 • maxwellTerm := by + simp only [maxwellTerm] + rw [massScale_tmul, map_one, massScalePhoton_tmul, + Photon.JetAlgebra.massScale_maxwellTerm, TensorProduct.tmul_smul, + real_smul_tmul, Complex.ofReal_pow] + +/-- The Dirac kinetic term has mass dimension four. -/ +theorem massScale_diracKineticTerm (c : ℝ) (e : ℝ) : + massScale c (diracKineticTerm e) = (c : ℂ) ^ 8 • diracKineticTerm e := by + rw [diracKineticTerm, map_smul, map_sum, smul_smul, + mul_comm ((c : ℂ) ^ 8) Complex.I, ← smul_smul] + congr 1 + rw [Finset.smul_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, map_mul, massScale_barψ_zero, massScale_covDψ, smul_mul_smul_comm, + ← pow_add, smul_comm] + +/-- The conjugate Dirac kinetic term has mass dimension four. -/ +theorem massScale_diracKineticTermBar (c : ℝ) (e : ℝ) : + massScale c (diracKineticTermBar e) = (c : ℂ) ^ 8 • diracKineticTermBar e := by + rw [diracKineticTermBar, map_smul, map_sum, smul_smul, + mul_comm ((c : ℂ) ^ 8) (-Complex.I), ← smul_smul] + congr 1 + rw [Finset.smul_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, map_mul, massScale_covDbarψ, massScale_ψ_zero, smul_mul_smul_comm, + ← pow_add, smul_comm] + +/-- The Dirac mass term has mass dimension three. -/ +theorem massScale_electronMassTerm (c : ℝ) : + massScale c electronMassTerm = (c : ℂ) ^ 6 • electronMassTerm := by + rw [electronMassTerm, map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun α _ => ?_ + rw [map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, map_mul, massScale_barψ_zero, massScale_ψ_zero, smul_mul_smul_comm, + ← pow_add, smul_comm] + +/-! + +## D. The mass dimension of the QED Lagrangian + +-/ + +/-- **The QED Lagrangian has mass dimension four.** Rescaling all fields by + their mass weights takes `L(e, c² m)` to `c⁸ L(e, m)`: the coupling `e` is + dimensionless and the electron mass is a coefficient of dimension one, so + every term of the Lagrangian is renormalizable. -/ +theorem massScale_lagrangian (c : ℝ) (e m : ℝ) : + massScale c (lagrangian e (c ^ 2 * m)) = (c : ℂ) ^ 8 • lagrangian e m := by + rw [lagrangian, lagrangian, map_sub, map_add, map_smul, map_smul, + massScale_maxwellTerm, massScale_diracKineticTerm, massScale_electronMassTerm] + simp only [smul_smul, smul_add, smul_sub] + push_cast + module + +end JetAlgebra + +end QED diff --git a/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean b/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean index 246f2ed65..c8942956c 100644 --- a/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet.lean @@ -6,7 +6,15 @@ Authors: Nathaneal Sajan module public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps /-! # Down-type singlets @@ -33,6 +41,10 @@ Model gauge group. - `mem_repGaugeGroupI_ker_iff_eq` : the kernel of the full-group action. - `gaugeGroup_subgroup_ℤ₆_le_ker_repGaugeGroupI` : triviality of the central `ℤ₆`. - `repGaugeGroup` : the action descended to every supported gauge-group quotient. +- `gaugeAlgebraAction` : the infinitesimal `(3, 1)_{-2}` action of the gauge algebra. +- `repJetGaugeGroupI` : the jet gauge action on jets of the down singlet. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action. ## iii. Table of contents @@ -42,6 +54,9 @@ Model gauge group. - D. Gauge action - E. Kernel of the gauge action - F. Descent to quotient gauge groups +- G. The action of the gauge algebra +- H. The representation of the jet gauge group +- I. The infinitesimal action underlies the jet gauge action -/ @@ -108,6 +123,21 @@ lemma val_smul (r : ℂ) (d : DownSinglet) : (r • d).val = r • d.val := rfl /-! +## The basis of the down-singlet space + +-/ + +/-- A basis on the down singlets. -/ +noncomputable def basis : Module.Basis (Fin 2 × Fin 3) ℂ DownSinglet := + (Fermion.RightHandedWeyl.basis.tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).map valLinEquiv.symm + +instance : Module.Finite ℂ DownSinglet := Module.Finite.of_basis basis + +instance : Module.Free ℂ DownSinglet := Module.Free.of_basis basis + +/-! + ## C. Lorentz action The Lorentz group acts on the right-handed Weyl factor and leaves the colour index fixed. @@ -287,6 +317,198 @@ noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂) | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃) +/-! + +## The representation of the jet gauge group +-/ + +/-- Absorbs the jet ring into the colour index: a jet of a down-type singlet is the +same thing as a right-handed Weyl spinor tensored with a `JetRing`-valued colour +vector, + + `JetRing ⊗[ℂ] DownSinglet ≃ RightHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3)`. + +-/ +noncomputable def jetValLinEquiv : + JetRing ⊗[ℂ] DownSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3) := + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ JetRing Fermion.RightHandedWeyl + (EuclideanSpace ℂ (Fin 3))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.RightHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) + (WithLp.linearEquiv 2 ℂ (Fin 3 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ JetRing JetRing (Fin 3)).trans + (WithLp.linearEquiv 2 JetRing (Fin 3 → JetRing)).symm).restrictScalars ℂ + +/-- The `(3, 1)_{-2}` action of the jet gauge group on the jet space of the down-type +singlet. Through `jetValLinEquiv` the colour matrix of the gauge jet, carrying the +`-2` hypercharge phase `(star u) ^ 2`, acts `JetRing`-linearly on the colour factor by +matrix-vector multiplication, while the Weyl factor is untouched. + +Both monoid laws come from bundled algebra maps — `Matrix.toLpLinAlgEquiv` and +`Module.End.lTensorAlgHom` are morphisms of algebras — so only the multiplicativity of +the colour-times-hypercharge matrix itself is checked. Note `Matrix.toLpLinAlgEquiv 2` +is the same map as the `Matrix.toEuclideanLin` used by `repGaugeGroupI`, which is an +abbreviation for `Matrix.toLpLin 2 2`, taken at the `CommRing` generality that +`JetRing` needs. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] DownSinglet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End JetRing (EuclideanSpace JetRing (Fin 3))).restrictScalars ℂ + = 1 := rfl + rw [show (((star (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing)) ^ 2) • + (((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) = 1 from by simp, + map_one, hres, map_one] + ext d x + simp [-valLinEquiv_apply] + map_mul' U₁ U₂ := by + have hres : ∀ f g : Module.End JetRing (EuclideanSpace JetRing (Fin 3)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + have hM : (((star (((U₁ * U₂).2.2 : unitary JetRing) : JetRing)) ^ 2) • + (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) = + (((star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U₁.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) * + (((star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U₂.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) := by + rw [show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) = + ((U₁.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) * + ((U₂.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + from rfl, + star_mul', mul_pow, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + rw [hM, map_mul, hres, map_mul] + ext d x + simp + +/-- The identification of the jets of the down-type singlet intertwines multiplication by +a scalar jet with the `JetRing`-scalar action on the colour coordinates. -/ +lemma jetValLinEquiv_smul (χ : JetRing) (z : JetRing ⊗[ℂ] DownSinglet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ).restrictScalars ℂ) + (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, map_add] + | tmul f x => + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : DownSinglet) = 0 from rfl, TensorProduct.tmul_zero, + smul_zero, map_zero, map_zero] + | tmul ψ c => + rw [TensorProduct.smul_tmul', smul_eq_mul, + show jetValLinEquiv ((χ * f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (χ * f)) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + show Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ).restrictScalars ℂ) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f)) + = ψ ⊗ₜ[ℂ] (χ • WithLp.toLp 2 fun i => c.ofLp i • f) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show c.ofLp i • (χ * f) = χ * (c.ofLp i • f) + rw [Algebra.mul_smul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : DownSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, smul_add, map_add, ha, hb, map_add, map_add] + +/-- **The jet gauge action on the jets of the down-type singlet is fibrewise**: it +commutes with multiplication by scalar jets, acting on the values of the field over the +identity on spacetime. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] DownSinglet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End JetRing (EuclideanSpace JetRing (Fin 3)) := + LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ with hS + set M : Module.End JetRing (EuclideanSpace JetRing (Fin 3)) := + (Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) : + Module.End JetRing (EuclideanSpace JetRing (Fin 3))) with hM + have hMS : M * S = S * M := LinearMap.ext fun e => by + simp only [Module.End.mul_apply, hS, LinearMap.lsmul_apply, map_smul] + apply jetValLinEquiv.injective + rw [show repJetGaugeGroupI U (χ • z) + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.RightHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv (χ • z))) from rfl, + LinearEquiv.apply_symm_apply, jetValLinEquiv_smul, + show repJetGaugeGroupI U z + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.RightHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv z)) from rfl, + jetValLinEquiv_smul, LinearEquiv.apply_symm_apply, ← Module.End.mul_apply, + ← Module.End.mul_apply, ← map_mul, ← map_mul, + show M.restrictScalars ℂ * S.restrictScalars ℂ = (M * S).restrictScalars ℂ from rfl, + show S.restrictScalars ℂ * M.restrictScalars ℂ = (S * M).restrictScalars ℂ from rfl, + hMS] + +/-- On jets of constant gauge transformations the jet action reduces to the global +gauge action on the fibre: the `(3, 1)_{-2}` action on the down-singlet factor, and the +trivial action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext d x + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => simp [show ({ val := 0 } : DownSinglet) = 0 from rfl] + | tmul psi c => + apply jetValLinEquiv.injective + simp [repJetGaugeGroupI, jetValLinEquiv, repGaugeGroupI] + have hu : star (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((starRingEnd ℂ) (g.toU1.1 : ℂ)) := by + rw [show (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) from rfl, JetRing.star_C] + rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).1 : + specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) i j + = MvPowerSeries.C (g.toSU3.1 i j) := fun _ _ => rfl + have halg : ∀ A : Matrix (Fin 3) (Fin 3) JetRing, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End JetRing (EuclideanSpace JetRing (Fin 3))) + = Matrix.toLpLin 2 2 A := fun _ => rfl + have hvec : ∀ i : Fin 3, + (∑ x, MvPowerSeries.C ((g.toSU3.1) i x) * (MvPowerSeries.C (c.ofLp x) * d)) + = MvPowerSeries.C (∑ x, (g.toSU3.1) i x * c.ofLp x) * d := by + intro i + rw [map_sum, Finset.sum_mul] + exact Finset.sum_congr rfl fun x _ => by rw [← mul_assoc, ← map_mul] + rw [TensorProduct.liftAux_tmul, ← TensorProduct.tmul_smul] + simp only [LinearMap.compl₂_apply, TensorProduct.mk_apply, LinearMap.smul_apply, + LinearMap.restrictScalars_apply, halg, Matrix.toLpLin_toLp] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + simp only [WithLp.ofLp_smul, Pi.smul_apply, Matrix.toLin'_apply, + Matrix.mulVec_apply_eq_sum, hM, Algebra.smul_def, MvPowerSeries.algebraMap_apply, + hu, map_pow, Algebra.algebraMap_self_apply] + rw [hvec i] + | add a b ha hb => + simp only [show ({ val := a + b } : DownSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + map_add, ha, hb] + end DownSinglet end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/DownSinglet/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/Fermions/DownSinglet/GaugeAlgebraAction.lean new file mode 100644 index 000000000..3e95cb5fd --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/DownSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,636 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.DownSinglet +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! + +# The infinitesimal gauge action on the down-type singlet + +## i. Overview + +The infinitesimal `(3, 1)_{-2}` action of the gauge algebra on the down-type singlet, +and the proof that it is the infinitesimal action underlying the jet gauge action +`DownSinglet.repJetGaugeGroupI`, in the sense of +`GaugeAlgebra.IsInfinitesimalActionOf`. + +## ii. Key results + +- `DownSinglet.gaugeAlgebraAction` : the infinitesimal `(3, 1)_{-2}` action. +- `DownSinglet.isInfinitesimalActionOf` : the action underlies the jet gauge action. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +namespace DownSinglet + +/-! + +## The action of the gauge algebra + +The infinitesimal `(3, 1)_{-2}` action of the gauge algebra on the down-type singlet: +the colour part of the algebra element acts on the colour index and the hypercharge +part scales, both through the physicists' factor of `i`, matching the group action +`(star u) ^ 2 • U₃` infinitesimally. The compatibility with the jet gauge action — +`GaugeAlgebra.IsInfinitesimalActionOf` — is proved at the end of this file. + +-/ + +/-- The endomorphism of the down singlet defined by a `3 × 3` complex matrix acting on + the colour index, with the Weyl factor untouched. -/ +noncomputable def colourEnd (A : Matrix (Fin 3) (Fin 3) ℂ) : + DownSinglet →ₗ[ℂ] DownSinglet := + valLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) ∘ₗ valLinEquiv.toLinearMap + +lemma colourEnd_apply_mk (A : Matrix (Fin 3) (Fin 3) ℂ) (v : DownSinglet) : + colourEnd A v + = valLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) (valLinEquiv v)) := rfl + +lemma colourEnd_add (A B : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (A + B) = colourEnd A + colourEnd B := by + rw [colourEnd, colourEnd, colourEnd, map_add, map_add, LinearMap.add_comp, + LinearMap.comp_add] + +lemma colourEnd_smul (z : ℂ) (A : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (z • A) = z • colourEnd A := by + rw [colourEnd, colourEnd, map_smul, map_smul, LinearMap.smul_comp, + LinearMap.comp_smul] + +lemma colourEnd_zero : colourEnd 0 = 0 := by + rw [colourEnd, map_zero, map_zero, LinearMap.zero_comp, LinearMap.comp_zero] + +lemma colourEnd_neg (A : Matrix (Fin 3) (Fin 3) ℂ) : colourEnd (-A) = -colourEnd A := by + rw [show (-A : Matrix (Fin 3) (Fin 3) ℂ) = (-1 : ℂ) • A from by rw [neg_one_smul], + colourEnd_smul, neg_one_smul] + +lemma colourEnd_multiset_sum (m : Multiset (Matrix (Fin 3) (Fin 3) ℂ)) : + colourEnd m.sum = (m.map colourEnd).sum := by + induction m using Multiset.induction_on with + | empty => simp [colourEnd_zero] + | cons A t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + colourEnd_add, ih] + +/-- The colour endomorphisms compose through matrix multiplication. -/ +lemma colourEnd_mul (A B : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (A * B) = colourEnd A ∘ₗ colourEnd B := by + refine LinearMap.ext fun v => ?_ + rw [colourEnd_apply_mk, map_mul, map_mul, LinearMap.comp_apply, colourEnd_apply_mk, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply] + rfl + +/-- The matrix of the infinitesimal `(3, 1)_{-2}` action of a gauge algebra element on + the colour index: `i` times the colour part, shifted by `i` times `-2` the + hypercharge. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : Matrix (Fin 3) (Fin 3) ℂ := + Complex.I • (c.toSU3Matrix - ((2 : ℂ) • c.toU1Value) • 1) + +/-- **The infinitesimal action of the gauge algebra on the down-type singlet**: the + derivative of the `(3, 1)_{-2}` action of the gauge group, real-linear in the + algebra slot and complex-linear in the value slot — the form consumed by the + covariant derivative `IsGaugeField.covDerivIter` and by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] DownSinglet →ₗ[ℂ] DownSinglet where + toFun c := colourEnd (actionMatrix c) + map_add' c₁ c₂ := by + rw [show actionMatrix (c₁ + c₂) = actionMatrix c₁ + actionMatrix c₂ from by + rw [actionMatrix, actionMatrix, actionMatrix, GaugeAlgebra.add_toSU3Matrix, + GaugeAlgebra.add_toU1Value] + module] + rw [colourEnd_add] + map_smul' r c := by + rw [show actionMatrix (r • c) = (r : ℂ) • actionMatrix c from by + rw [actionMatrix, actionMatrix, GaugeAlgebra.smul_toSU3Matrix, + GaugeAlgebra.smul_toU1Value, + show (r • c.toSU3Matrix : Matrix (Fin 3) (Fin 3) ℂ) + = (r : ℂ) • c.toSU3Matrix from by + rw [← algebraMap_smul ℂ r c.toSU3Matrix]; rfl, + show r • c.toU1Value = (r : ℂ) • c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value]; rfl] + module, + colourEnd_smul] + refine LinearMap.ext fun v => ?_ + rw [RingHom.id_apply] + show (r : ℂ) • colourEnd (actionMatrix c) v = r • colourEnd (actionMatrix c) v + rw [show ((r : ℝ) : ℂ) = algebraMap ℝ ℂ r from rfl, algebraMap_smul] + +/-! + +## The infinitesimal action underlies the jet gauge action + +The `(3, 1)_{-2}` action of the gauge algebra is the infinitesimal action underlying the +jet gauge action, in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`: the base-point +Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law and +intertwine the action with the adjoint transports. The proofs work through the colour +matrix of the jet action and the all-orders matrix Leibniz rule at the base point. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : JetRing) : + pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) f) + = x.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, ih, JetRing.pderiv_comm] + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The iterated formal derivative of a difference. -/ +private lemma foldl_pderiv_sub (x : Multiset (Fin 1 ⊕ Fin 3)) (f g : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (f - g) + = x.foldl (fun h ρ => pderiv ℂ ρ h) f - x.foldl (fun h ρ => pderiv ℂ ρ h) g := by + induction x using Multiset.induction_on generalizing f g with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_sub, ih, Multiset.foldl_cons, + Multiset.foldl_cons] + +/-- The jet-valued matrix of the infinitesimal `(3, 1)_{-2}` action of a jet of gauge + algebra elements: the jet analogue of `actionMatrix`. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : Matrix (Fin 3) (Fin 3) JetRing := + Complex.I • (a.toSU3Matrix - ((2 : ℂ) • a.toU1Value) • 1) + +/-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ +lemma jetActionMatrix_map_cc_foldl (p : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + ((jetActionMatrix a).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := by + ext i j + rw [Matrix.map_apply, jetActionMatrix, actionMatrix, Matrix.smul_apply, + Matrix.sub_apply, Matrix.smul_apply, Matrix.smul_apply, Matrix.sub_apply, + Matrix.smul_apply, foldl_pderiv_smul, constantCoeff_smul, foldl_pderiv_sub, + map_sub, JetGaugeAlgebra.eval_iteratedDeriv_toSU3Matrix, Matrix.map_apply] + congr 2 + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq, smul_eq_mul, mul_one, smul_eq_mul, + mul_one, foldl_pderiv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + JetRing.foldl_pderiv_zero, map_zero] + +/-- The `JetRing`-valued colour matrix of the jet gauge action on the down singlet: the + colour matrix of the gauge jet carrying the `-2` hypercharge phase. -/ +noncomputable def downMatrix (U : JetGaugeGroupI) : Matrix (Fin 3) (Fin 3) JetRing := + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + +lemma repJetGaugeGroupI_eq_downMatrix (U : JetGaugeGroupI) + (z : JetRing ⊗[ℂ] DownSinglet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)).restrictScalars ℂ) + (jetValLinEquiv z)) := rfl + +/-- The entrywise formal derivative on the colour coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivColour (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace JetRing (Fin 3) where + toFun v := WithLp.toLp 2 fun i => pderiv ℂ μ (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact Derivation.map_smul _ _ _ + +/-- The entrywise iterated formal derivative on the colour coordinates. -/ +private noncomputable def foldColour (x : Multiset (Fin 1 ⊕ Fin 3)) : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace JetRing (Fin 3) where + toFun v := WithLp.toLp 2 fun i => x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact JetRing.foldl_pderiv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact foldl_pderiv_smul x z _ + +/-- The entrywise base-point evaluation on the colour coordinates. -/ +private noncomputable def ccColour : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun v := WithLp.toLp 2 fun i => constantCoeff (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact constantCoeff_smul _ _ + +private lemma pderivColour_comp_foldColour (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivColour μ ∘ₗ foldColour x = foldColour (μ ::ₘ x) := by + refine LinearMap.ext fun v => ?_ + refine WithLp.ofLp_injective 2 ?_ + funext i + show pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i)) + = (μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + rw [Multiset.foldl_cons, pderiv_foldl] + +/-- The identification of down-singlet jets intertwines the formal derivative with the + entrywise derivative on the colour coordinates. -/ +private lemma jetValLinEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (z : JetRing ⊗[ℂ] DownSinglet) : + jetValLinEquiv (StandardModel.jetDeriv μ z) + = (TensorProduct.map LinearMap.id (pderivColour μ)) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : DownSinglet) = 0 from rfl, TensorProduct.tmul_zero, + map_zero, map_zero, map_zero] + | tmul ψ c => + rw [show StandardModel.jetDeriv μ (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = (pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet) from rfl, + show jetValLinEquiv ((pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • pderiv ℂ μ f) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + exact (Derivation.map_smul (pderiv ℂ μ) (c.ofLp i) f).symm + | add a b ha hb => + rw [show ({ val := a + b } : DownSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +/-- The identification of down-singlet jets intertwines the iterated formal derivative + with the entrywise iterated derivative on the colour coordinates. -/ +private lemma jetValLinEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) + (z : JetRing ⊗[ℂ] DownSinglet) : + jetValLinEquiv (StandardModel.jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColour x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [StandardModel.jetIteratedDeriv_zero, LinearMap.id_apply, + show foldColour 0 = LinearMap.id from LinearMap.ext fun v => + WithLp.ofLp_injective 2 rfl, + TensorProduct.map_id, LinearMap.id_apply] + | cons μ t ih => + rw [StandardModel.jetIteratedDeriv_cons, LinearMap.comp_apply, + jetValLinEquiv_jetDeriv, ih, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, pderivColour_comp_foldColour] + +/-- The base-point evaluation of a down-singlet jet through the colour coordinates. -/ +private lemma valLinEquiv_jetEval (z : JetRing ⊗[ℂ] DownSinglet) : + valLinEquiv (StandardModel.jetEval z) + = (TensorProduct.map LinearMap.id ccColour) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp; rfl + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : DownSinglet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rfl + | tmul ψ c => + rw [StandardModel.jetEval_tmul, map_smul, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet) = ψ ⊗ₜ[ℂ] c from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply, ← TensorProduct.tmul_smul] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show (constantCoeff f • c).ofLp i = constantCoeff (c.ofLp i • f) + simp [constantCoeff_smul, mul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : DownSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +set_option maxHeartbeats 1000000 in +/-- **The derivative identity** for the colour matrix of the jet gauge action: the + formal derivative of the colour matrix is minus the jet action matrix of the + Maurer–Cartan form times the colour matrix. -/ +lemma downMatrix_map_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (downMatrix U).map (fun f => pderiv ℂ μ f) + = -(jetActionMatrix (maurerCartanForm U μ) * downMatrix U) := by + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + have h0 : pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) = 0 := by + have h := congrArg (pderiv ℂ μ) huu + rw [hleib, Derivation.map_one_eq_zero] at h + exact h + have hsu : pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) + = -(pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * (star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing))) := by + have h1 : star ((U.2.2 : unitary JetRing) : JetRing) + * (pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) * huu + have hm₃U₃ : (maurerCartanForm U μ).toSU3Matrix * U.1.1 + = Complex.I • U.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU3Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₃u, + Matrix.mul_one] + have hiC : (algebraMap ℂ JetRing) Complex.I * (algebraMap ℂ JetRing) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : ((((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)).map fun f => pderiv ℂ μ f) + = (pderiv ℂ μ ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2)) • U.1.1 + + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) + • (U.1.1.map (pderiv ℂ μ)) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul] + exact hleib _ _ + rw [downMatrix, jetActionMatrix, hmap, Matrix.smul_mul, Matrix.sub_mul, + Matrix.mul_smul, hm₃U₃, Matrix.smul_mul, Matrix.one_mul, + smul_comm ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) Complex.I, + smul_sub, smul_smul Complex.I Complex.I, Complex.I_mul_I, neg_one_smul, + ← smul_assoc, neg_sub, sub_neg_eq_add, smul_smul] + congr 1 + congr 1 + rw [maurerCartanForm_toU1Value, sq, hleib, hsu, Algebra.smul_def, + Algebra.smul_def, Algebra.smul_def, map_ofNat] + linear_combination (-(2 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing))) * hiC + +/-- **The equivariance identity** for the colour matrix of the jet gauge action: the + colour matrix intertwines the constant jet action matrix with its adjoint + transform. -/ +lemma downMatrix_mul_jetActionMatrix (U : JetGaugeGroupI) (c : GaugeAlgebra) : + downMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = jetActionMatrix (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c)) + * downMatrix U := by + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rw [downMatrix, jetActionMatrix, jetActionMatrix, + JetGaugeAlgebra.adjointMap_toSU3Matrix, JetGaugeAlgebra.adjointMap_toU1Value] + conv_lhs => rw [Matrix.mul_smul, Matrix.smul_mul, Matrix.mul_sub, Matrix.mul_smul, + Matrix.mul_one] + conv_rhs => rw [Matrix.smul_mul, Matrix.sub_mul, Matrix.mul_smul, + Matrix.smul_mul, Matrix.one_mul, Matrix.mul_assoc, hU₃u, Matrix.mul_one] + rw [smul_sub, smul_comm ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 2) + ((2 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +set_option maxHeartbeats 1000000 in +/-- **The base-point Taylor coefficients of the jet gauge action** on the down-type + singlet are the colour endomorphisms of the base-point Taylor coefficients of the + colour matrix. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = colourEnd ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x d + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_downMatrix, LinearEquiv.apply_symm_apply, + StandardModel.jetOfConstant_apply] + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : DownSinglet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rw [show (0 : DownSinglet).val = 0 from rfl, map_zero] + | add a b ha hb => + rw [show ({ val := a + b } : DownSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, map_add, map_add, ha, hb, map_add, + map_add] + | tmul ψ c => + rw [show jetValLinEquiv ((1 : JetRing) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) from rfl, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : DownSinglet) = ψ ⊗ₜ[ℂ] c from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) + Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (downMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j + = ∑ k, downMatrix U j k * (c.ofLp k • (1 : JetRing)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + = ∑ k, constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (downMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + JetRing.foldl_pderiv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + mul_comm] + +/-- The colour endomorphism of the identity matrix is the identity. -/ +lemma colourEnd_one : colourEnd 1 = LinearMap.id := by + refine LinearMap.ext fun v => ?_ + rw [colourEnd_apply_mk, map_one, map_one, Module.End.one_apply, + LinearEquiv.symm_apply_apply, LinearMap.id_apply] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((downMatrix U).map fun f => + constantCoeff ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, Multiset.foldl_zero, downMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, JetRing.constantCoeff_star, hu, star_one, + one_pow, one_mul] + exact Matrix.ext_iff.mpr h1 i j + rw [repCoeff_eq, hM, colourEnd_one] + + +set_option maxHeartbeats 1000000 in +/-- **The `(3, 1)_{-2}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the down-type singlet**: its base-point Taylor + coefficients obey the Maurer–Cartan Leibniz law and intertwine the action with the + adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : ((downMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((downMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum) := by + rw [show ((downMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (((downMatrix U).map fun f => pderiv ℂ μ f).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + Multiset.foldl_cons], + downMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * downMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * downMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, foldl_pderiv_neg, map_neg], + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [jetActionMatrix_map_cc_foldl])) + rw [repCoeff_eq, hMcons, colourEnd_neg, colourEnd_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, colourEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hCsmul : ∀ z w : ℂ, (z • (C w : JetRing)) = C (z * w) := fun z w => by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + Algebra.algebraMap_self_apply, ← map_mul] + have hconst : jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = (actionMatrix c).map (C : ℂ → JetRing) := by + refine Matrix.ext fun i j => ?_ + rw [jetActionMatrix, actionMatrix, JetGaugeAlgebra.ofConstant_toSU3Matrix, + JetGaugeAlgebra.ofConstant_toU1Value, Matrix.map_apply, Matrix.smul_apply, + Matrix.sub_apply, Matrix.map_apply, Matrix.smul_apply, Matrix.smul_apply, + Matrix.sub_apply, Matrix.smul_apply] + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq] + simp only [smul_eq_mul, mul_one] + rw [hCsmul, ← map_sub, hCsmul] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + sub_zero, sub_zero, hCsmul] + exact congrArg C (by ring) + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((actionMatrix c).map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then actionMatrix c else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, constantCoeff_C] + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (IsGaugeField.adjointCoeff U p.1 c) + * ((downMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have h1 : ((downMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c := by + rw [hconst, matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((downMatrix U).map fun f => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p hp => by rw [if_neg hp, Matrix.mul_zero]), + if_pos rfl] + rw [← h1, downMatrix_mul_jetActionMatrix, matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [jetActionMatrix_map_cc_foldl, + show JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c))) + = IsGaugeField.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourEnd ((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + ∘ₗ gaugeAlgebraAction c + = colourEnd (((downMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c) from by + rw [colourEnd_mul]; rfl, + hMact, colourEnd_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, colourEnd_mul, repCoeff_eq] + rfl + +end InfinitesimalAction + +end DownSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean new file mode 100644 index 000000000..1c66ecb01 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean @@ -0,0 +1,547 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Prod +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.MassDim +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet +public import Physlib.Particles.StandardModel.Fermions.UpSinglet +public import Physlib.Particles.StandardModel.Fermions.DownSinglet +/-! +# The fermionic jet algebra of the Standard Model + +## i. Overview + +The jet algebra of the Standard Model is the algebra in which a Lagrangian lives: the free +algebra on the component functions of every field and all their spacetime derivatives, +subject only to the statistics of the fields. + +This file builds its fermionic factor, `FermionJetAlgebra`; the bosonic factors — the gauge +fields and the Higgs — commute with everything and will enter as separate tensor factors. + +The Standard Model carries five fermion species — the lepton doublet, the charged-lepton +singlet, the quark doublet, and the up- and down-type quark singlets — each in three +generations, and the fermionic jet algebra is the *exterior product* of their individual +fermionic algebras: generators anticommute, and they do so **across species and generations +as well as within a species**, since all of them are fermionic. + +That exterior product is *realized* here as a single exterior algebra on the direct sum of +the fifteen target spaces, and then *identified* with the graded tensor product of the +species algebras by `FermionicAlgebra.prodEquiv`, applied once per species +(`FermionJetAlgebra.exteriorProductLeptonDoublet` and its siblings below). The +identification is genuine, not a convention: the exterior algebra of a direct sum is the +graded (super) tensor product of the exterior algebras of the summands. An ordinary tensor +product `⊗[ℂ]` would instead make generators of different species *commute*, which is wrong +for fermions. + +The direct sum is taken as the definition rather than the graded tensor product because +Mathlib's `GradedTensorProduct` carries no `GradedAlgebra` instance, so a graded tensor +product of three or more factors cannot currently be written down as a type; the peeled +form, one species at a time, is as far as the type-level statement goes. Working inside a +single `ExteriorAlgebra` also keeps every algebraic class projecting from one root, and lets +the whole `FermionicAlgebra` API — the Lorentz action, the jet gauge action, the total +derivative and its iterates — apply to `FermionJetAlgebra` unchanged. + +## ii. Key results + +- `FermionSpace` : the total target space of the Standard Model fermions. +- `FermionSpace.leptonDoubletProj`, … : the projections onto a species and generation. +- `FermionSpace.leptonDoubletIncl`, … : the inclusions of a species and generation. +- `FermionJetAlgebra` : the jet algebra of the Standard Model fermions. +- `FermionJetAlgebra.ofLeptonDoublet`, … : the component functions of each species and + generation. +- `FermionJetAlgebra.exteriorProductLeptonDoublet`, … : the jet algebra as the exterior + product of the species algebras. + +## iii. Table of contents + +- A. The target space of the Standard Model fermions + - A.1. The projections onto the species + - A.2. The inclusions onto the species + - A.3. The action of the Lorentz group + - A.4. The action of the global gauge group + - A.5. The action of the jet gauge group +- B. The fermionic jet algebra + - B.1. The component functions of each species + - B.2. The exterior product decomposition + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-! + +## A. The target space of the Standard Model fermions + +-/ + +TODO "Move FermionSpace to a seperate file by itself." + +TODO "For FermionSpace define the infinitismal action." + +/-- The total target space of the Standard Model fermions: the direct sum of three + generations each of the lepton doublet, the charged-lepton singlet, the quark doublet, and + the up- and down-type quark singlets. The three generations of a species sit together, so + that a species can be split off the jet algebra as a single exterior factor. -/ +abbrev FermionSpace : Type := + (Fin 3 → LeptonDoublet) × (Fin 3 → LeptonSinglet) × (Fin 3 → QuarkDoublet) × + (Fin 3 → UpSinglet) × (Fin 3 → DownSinglet) + +namespace FermionSpace + +/-! + +### A.1. The projections onto the species + +The component functions of a field are *covectors* on its target space, so it is the +projections — not the inclusions — that carry the individual species into the jet algebra. +Each projection takes a generation index `i : Fin 3`. + +-/ + +/-- The projection onto the `i`-th generation of the lepton doublet. -/ +def leptonDoubletProj (i : Fin 3) : FermionSpace →ₗ[ℂ] LeptonDoublet := + (LinearMap.proj i).comp (LinearMap.fst ℂ _ _) + +/-- The projection onto the `i`-th generation of the charged-lepton singlet. -/ +def leptonSingletProj (i : Fin 3) : FermionSpace →ₗ[ℂ] LeptonSinglet := + (LinearMap.proj i).comp ((LinearMap.fst ℂ _ _).comp (LinearMap.snd ℂ _ _)) + +/-- The projection onto the `i`-th generation of the quark doublet. -/ +def quarkDoubletProj (i : Fin 3) : FermionSpace →ₗ[ℂ] QuarkDoublet := + (LinearMap.proj i).comp + ((LinearMap.fst ℂ _ _).comp ((LinearMap.snd ℂ _ _).comp (LinearMap.snd ℂ _ _))) + +/-- The projection onto the `i`-th generation of the up-type quark singlet. -/ +def upSingletProj (i : Fin 3) : FermionSpace →ₗ[ℂ] UpSinglet := + (LinearMap.proj i).comp ((LinearMap.fst ℂ _ _).comp + ((LinearMap.snd ℂ _ _).comp ((LinearMap.snd ℂ _ _).comp (LinearMap.snd ℂ _ _)))) + +/-- The projection onto the `i`-th generation of the down-type quark singlet. -/ +def downSingletProj (i : Fin 3) : FermionSpace →ₗ[ℂ] DownSinglet := + (LinearMap.proj i).comp ((LinearMap.snd ℂ _ _).comp + ((LinearMap.snd ℂ _ _).comp ((LinearMap.snd ℂ _ _).comp (LinearMap.snd ℂ _ _)))) + +/-! + +### A.2. The inclusions onto the species + +The one-sided inverses of the projections: the inclusion of a single species and generation +as a summand of the total target space, zero in every other slot. `…Proj i ∘ …Incl i` is the +identity, and every other composite of a projection with an inclusion vanishes. + +-/ + +/-- The inclusion of the `i`-th generation lepton doublet as a summand. -/ +def leptonDoubletIncl (i : Fin 3) : LeptonDoublet →ₗ[ℂ] FermionSpace := + (LinearMap.inl ℂ _ _).comp (LinearMap.single ℂ (fun _ : Fin 3 => LeptonDoublet) i) + +/-- The inclusion of the `i`-th generation charged-lepton singlet as a summand. -/ +def leptonSingletIncl (i : Fin 3) : LeptonSinglet →ₗ[ℂ] FermionSpace := + (LinearMap.inr ℂ _ _).comp ((LinearMap.inl ℂ _ _).comp + (LinearMap.single ℂ (fun _ : Fin 3 => LeptonSinglet) i)) + +/-- The inclusion of the `i`-th generation quark doublet as a summand. -/ +def quarkDoubletIncl (i : Fin 3) : QuarkDoublet →ₗ[ℂ] FermionSpace := + (LinearMap.inr ℂ _ _).comp ((LinearMap.inr ℂ _ _).comp + ((LinearMap.inl ℂ _ _).comp + (LinearMap.single ℂ (fun _ : Fin 3 => QuarkDoublet) i))) + +/-- The inclusion of the `i`-th generation up-type quark singlet as a summand. -/ +def upSingletIncl (i : Fin 3) : UpSinglet →ₗ[ℂ] FermionSpace := + (LinearMap.inr ℂ _ _).comp ((LinearMap.inr ℂ _ _).comp ((LinearMap.inr ℂ _ _).comp + ((LinearMap.inl ℂ _ _).comp + (LinearMap.single ℂ (fun _ : Fin 3 => UpSinglet) i)))) + +/-- The inclusion of the `i`-th generation down-type quark singlet as a summand. -/ +def downSingletIncl (i : Fin 3) : DownSinglet →ₗ[ℂ] FermionSpace := + (LinearMap.inr ℂ _ _).comp ((LinearMap.inr ℂ _ _).comp ((LinearMap.inr ℂ _ _).comp + ((LinearMap.inr ℂ _ _).comp + (LinearMap.single ℂ (fun _ : Fin 3 => DownSinglet) i)))) + +@[simp] +lemma leptonDoubletProj_comp_leptonDoubletIncl (i : Fin 3) : + (leptonDoubletProj i).comp (leptonDoubletIncl i) = LinearMap.id := + LinearMap.ext fun _ => by simp [leptonDoubletProj, leptonDoubletIncl] + +@[simp] +lemma leptonSingletProj_comp_leptonSingletIncl (i : Fin 3) : + (leptonSingletProj i).comp (leptonSingletIncl i) = LinearMap.id := + LinearMap.ext fun _ => by simp [leptonSingletProj, leptonSingletIncl] + +@[simp] +lemma quarkDoubletProj_comp_quarkDoubletIncl (i : Fin 3) : + (quarkDoubletProj i).comp (quarkDoubletIncl i) = LinearMap.id := + LinearMap.ext fun _ => by simp [quarkDoubletProj, quarkDoubletIncl] + +@[simp] +lemma upSingletProj_comp_upSingletIncl (i : Fin 3) : + (upSingletProj i).comp (upSingletIncl i) = LinearMap.id := + LinearMap.ext fun _ => by simp [upSingletProj, upSingletIncl] + +@[simp] +lemma downSingletProj_comp_downSingletIncl (i : Fin 3) : + (downSingletProj i).comp (downSingletIncl i) = LinearMap.id := + LinearMap.ext fun _ => by simp [downSingletProj, downSingletIncl] + +/-! + +### A.3. The action of the Lorentz group + +-/ + +/-- The pointwise representation on a finite power of the representation space. -/ +noncomputable def _root_.Representation.pi {k G V : Type*} (ι : Type*) [CommSemiring k] + [Monoid G] [AddCommMonoid V] [Module k V] (ρ : Representation k G V) : + Representation k G (ι → V) where + toFun g := LinearMap.piMap fun _ => ρ g + map_one' := by + refine LinearMap.ext fun v => funext fun i => ?_ + simp + map_mul' g₁ g₂ := by + refine LinearMap.ext fun v => funext fun i => ?_ + simp [Module.End.mul_apply] + +open Matrix MatrixGroups in +/-- The Lorentz action on the total fermionic target space: each species and generation + transforms in its own Lorentz representation. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) FermionSpace := + ((LeptonDoublet.repLorentzGroup.pi (Fin 3)).prod + ((LeptonSinglet.repLorentzGroup.pi (Fin 3)).prod + ((QuarkDoublet.repLorentzGroup.pi (Fin 3)).prod + ((UpSinglet.repLorentzGroup.pi (Fin 3)).prod + (DownSinglet.repLorentzGroup.pi (Fin 3)))))) + +/-! + +### A.4. The action of the global gauge group + +-/ + +/-- The global gauge action on the total fermionic target space: each species and + generation transforms in its own representation of the gauge group. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI FermionSpace := + ((LeptonDoublet.repGaugeGroupI.pi (Fin 3)).prod + ((LeptonSinglet.repGaugeGroupI.pi (Fin 3)).prod + ((QuarkDoublet.repGaugeGroupI.pi (Fin 3)).prod + ((UpSinglet.repGaugeGroupI.pi (Fin 3)).prod + (DownSinglet.repGaugeGroupI.pi (Fin 3)))))) + +/-! + +### A.5. The action of the jet gauge group + +The jets of the total fermionic field split as the product of the jets of the species, +generation by generation; a jet of gauge transformations acts on each factor through the +species' own jet action. The identification is `JetRing`-linear, so the fibrewise +linearity of the species actions is inherited by the product. + +-/ + +open TensorProduct in +/-- The jets of the total fermionic field as the product of the jets of the species and + generations. The identification is `JetRing`-linear. -/ +noncomputable def jetEquiv : + JetRing ⊗[ℂ] FermionSpace ≃ₗ[JetRing] + (Fin 3 → JetRing ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → JetRing ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] UpSinglet) × + (Fin 3 → JetRing ⊗[ℂ] DownSinglet)))) := + (TensorProduct.prodRight ℂ JetRing JetRing _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ JetRing JetRing _) <| + (TensorProduct.prodRight ℂ JetRing JetRing _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ JetRing JetRing _) <| + (TensorProduct.prodRight ℂ JetRing JetRing _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ JetRing JetRing _) <| + (TensorProduct.prodRight ℂ JetRing JetRing _ _).trans <| + LinearEquiv.prodCongr (TensorProduct.piRight ℂ JetRing JetRing _) + (TensorProduct.piRight ℂ JetRing JetRing _) + +open TensorProduct in +/-- The map through which a jet of gauge transformations acts on the jets of the total + fermionic field: the species actions, factor by factor. -/ +noncomputable def jetActionMap (U : JetGaugeGroupI) : + ((Fin 3 → JetRing ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → JetRing ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] UpSinglet) × + (Fin 3 → JetRing ⊗[ℂ] DownSinglet))))) →ₗ[ℂ] + ((Fin 3 → JetRing ⊗[ℂ] LeptonDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] LeptonSinglet) × + ((Fin 3 → JetRing ⊗[ℂ] QuarkDoublet) × + ((Fin 3 → JetRing ⊗[ℂ] UpSinglet) × + (Fin 3 → JetRing ⊗[ℂ] DownSinglet))))) := + LinearMap.prodMap (LinearMap.piMap fun _ => LeptonDoublet.repJetGaugeGroupI U) + (LinearMap.prodMap (LinearMap.piMap fun _ => LeptonSinglet.repJetGaugeGroupI U) + (LinearMap.prodMap (LinearMap.piMap fun _ => QuarkDoublet.repJetGaugeGroupI U) + (LinearMap.prodMap (LinearMap.piMap fun _ => UpSinglet.repJetGaugeGroupI U) + (LinearMap.piMap fun _ => DownSinglet.repJetGaugeGroupI U)))) + +/-- The pointwise lift of the identity maps is the identity. -/ +lemma _root_.LinearMap.piMap_id {R ι : Type*} {φ : ι → Type*} [Semiring R] + [∀ i, AddCommMonoid (φ i)] [∀ i, Module R (φ i)] : + LinearMap.piMap (fun i => (LinearMap.id : φ i →ₗ[R] φ i)) = LinearMap.id := + LinearMap.ext fun _ => funext fun _ => rfl + +/-- The pointwise lift of compositions is the composition of the pointwise lifts. -/ +lemma _root_.LinearMap.piMap_comp_piMap {R ι : Type*} {φ ψ ω : ι → Type*} [Semiring R] + [∀ i, AddCommMonoid (φ i)] [∀ i, Module R (φ i)] + [∀ i, AddCommMonoid (ψ i)] [∀ i, Module R (ψ i)] + [∀ i, AddCommMonoid (ω i)] [∀ i, Module R (ω i)] + (f : ∀ i, ψ i →ₗ[R] ω i) (g : ∀ i, φ i →ₗ[R] ψ i) : + (LinearMap.piMap f).comp (LinearMap.piMap g) + = LinearMap.piMap fun i => (f i).comp (g i) := + LinearMap.ext fun _ => funext fun _ => rfl + +open TensorProduct in +/-- The map of jets of the identity is the identity. -/ +lemma jetActionMap_one : jetActionMap 1 = LinearMap.id := by + rw [jetActionMap] + simp only [map_one, Module.End.one_eq_id, LinearMap.piMap_id, LinearMap.prodMap_id] + +open TensorProduct in +/-- The map of jets of a product is the composition of the maps of jets. -/ +lemma jetActionMap_mul (U V : JetGaugeGroupI) : + jetActionMap (U * V) = (jetActionMap U).comp (jetActionMap V) := by + rw [jetActionMap, jetActionMap, jetActionMap, LinearMap.prodMap_comp, + LinearMap.prodMap_comp, LinearMap.prodMap_comp, LinearMap.prodMap_comp, + LinearMap.piMap_comp_piMap, LinearMap.piMap_comp_piMap, LinearMap.piMap_comp_piMap, + LinearMap.piMap_comp_piMap, LinearMap.piMap_comp_piMap] + simp only [map_mul, Module.End.mul_eq_comp] + +open TensorProduct in +set_option maxRecDepth 4000 in +/-- **The jet gauge action on the jets of the total fermionic field**: the species + actions, transported through the splitting of the jets. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] FermionSpace) where + toFun U := (jetEquiv.restrictScalars ℂ).symm.toLinearMap ∘ₗ jetActionMap U ∘ₗ + (jetEquiv.restrictScalars ℂ).toLinearMap + map_one' := by + refine LinearMap.ext fun z => ?_ + show (jetEquiv.restrictScalars ℂ).symm (jetActionMap 1 + ((jetEquiv.restrictScalars ℂ) z)) = z + rw [jetActionMap_one, LinearMap.id_apply] + exact (jetEquiv.restrictScalars ℂ).symm_apply_apply z + map_mul' U V := by + refine LinearMap.ext fun z => ?_ + show (jetEquiv.restrictScalars ℂ).symm (jetActionMap (U * V) + ((jetEquiv.restrictScalars ℂ) z)) + = (jetEquiv.restrictScalars ℂ).symm (jetActionMap U ((jetEquiv.restrictScalars ℂ) + ((jetEquiv.restrictScalars ℂ).symm (jetActionMap V + ((jetEquiv.restrictScalars ℂ) z))))) + rw [(jetEquiv.restrictScalars ℂ).apply_symm_apply, jetActionMap_mul, + LinearMap.comp_apply] + +open TensorProduct in +set_option maxRecDepth 4000 in +/-- **The jet gauge action on the jets of the total fermionic field is fibrewise**: it + commutes with multiplication by scalar jets, because the splitting of the jets is + `JetRing`-linear and each species action is fibrewise. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] FermionSpace) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + have hact : ∀ w, jetActionMap U (χ • w) = χ • jetActionMap U w := by + intro w + refine Prod.ext (funext fun i => ?_) (Prod.ext (funext fun i => ?_) + (Prod.ext (funext fun i => ?_) (Prod.ext (funext fun i => ?_) + (funext fun i => ?_)))) + · exact LeptonDoublet.repJetGaugeGroupI_smul U χ _ + · exact LeptonSinglet.repJetGaugeGroupI_smul U χ _ + · exact QuarkDoublet.repJetGaugeGroupI_smul U χ _ + · exact UpSinglet.repJetGaugeGroupI_smul U χ _ + · exact DownSinglet.repJetGaugeGroupI_smul U χ _ + show (jetEquiv.restrictScalars ℂ).symm (jetActionMap U + ((jetEquiv.restrictScalars ℂ) (χ • z))) + = χ • (jetEquiv.restrictScalars ℂ).symm (jetActionMap U + ((jetEquiv.restrictScalars ℂ) z)) + rw [show (jetEquiv.restrictScalars ℂ) (χ • z) = χ • (jetEquiv.restrictScalars ℂ) z from + map_smul jetEquiv χ z, + hact, + show (jetEquiv.restrictScalars ℂ).symm (χ • jetActionMap U + ((jetEquiv.restrictScalars ℂ) z)) + = χ • (jetEquiv.restrictScalars ℂ).symm (jetActionMap U + ((jetEquiv.restrictScalars ℂ) z)) from + map_smul jetEquiv.symm χ _] + +end FermionSpace + +/-! + +## B. The fermionic jet algebra + +-/ + +/-- **The jet algebra of the Standard Model fermions**: the exterior product of the fermionic + algebras of the five species, realized as the fermionic algebra of their direct sum. Its + generators are the component functions `∂_s ψ_φ` and `∂_s ψ̄_φ` of every species and + generation, and any two of them anticommute — within a species and across species alike. + + This is the fermionic factor of the full Standard Model jet algebra; the gauge and Higgs + factors are bosonic and commute with it. -/ +abbrev FermionJetAlgebra : Type := FermionicAlgebra FermionSpace + +namespace FermionJetAlgebra + +/-! + +### B.1. The component functions of each species + +Each species and generation enters through its projection out of `FermionSpace`: a covector +on the species pulls back to a covector on the total target space, and thence to a generator +of the jet algebra. Their iterated derivatives `FermionicAlgebra.iteratedJetDeriv` are the +higher generators. + +-/ + +/-- The component functions of the `i`-th generation lepton doublet inside the Standard + Model jet algebra. -/ +noncomputable def ofLeptonDoublet (i : Fin 3) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofField.comp (Module.Dual.transpose (FermionSpace.leptonDoubletProj i)) + +/-- The component functions of the `i`-th generation charged-lepton singlet. -/ +noncomputable def ofLeptonSinglet (i : Fin 3) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofField.comp (Module.Dual.transpose (FermionSpace.leptonSingletProj i)) + +/-- The component functions of the `i`-th generation quark doublet. -/ +noncomputable def ofQuarkDoublet (i : Fin 3) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofField.comp (Module.Dual.transpose (FermionSpace.quarkDoubletProj i)) + +/-- The component functions of the `i`-th generation up-type quark singlet. -/ +noncomputable def ofUpSinglet (i : Fin 3) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofField.comp (Module.Dual.transpose (FermionSpace.upSingletProj i)) + +/-- The component functions of the `i`-th generation down-type quark singlet. -/ +noncomputable def ofDownSinglet (i : Fin 3) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofField.comp (Module.Dual.transpose (FermionSpace.downSingletProj i)) + +/-- The conjugate component functions of the `i`-th generation lepton doublet. -/ +noncomputable def ofConjLeptonDoublet (i : Fin 3) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofConjField.comp + (Module.Dual.transpose (ConjModule.map (FermionSpace.leptonDoubletProj i))) + +/-- The conjugate component functions of the `i`-th generation charged-lepton singlet. -/ +noncomputable def ofConjLeptonSinglet (i : Fin 3) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofConjField.comp + (Module.Dual.transpose (ConjModule.map (FermionSpace.leptonSingletProj i))) + +/-- The conjugate component functions of the `i`-th generation quark doublet. -/ +noncomputable def ofConjQuarkDoublet (i : Fin 3) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofConjField.comp + (Module.Dual.transpose (ConjModule.map (FermionSpace.quarkDoubletProj i))) + +/-- The conjugate component functions of the `i`-th generation up-type quark singlet. -/ +noncomputable def ofConjUpSinglet (i : Fin 3) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofConjField.comp + (Module.Dual.transpose (ConjModule.map (FermionSpace.upSingletProj i))) + +/-- The conjugate component functions of the `i`-th generation down-type quark singlet. -/ +noncomputable def ofConjDownSinglet (i : Fin 3) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] FermionJetAlgebra := + FermionicAlgebra.ofConjField.comp + (Module.Dual.transpose (ConjModule.map (FermionSpace.downSingletProj i))) + +/-! + +### B.2. The exterior product decomposition + +`FermionicAlgebra.prodEquiv` identifies the fermionic algebra of a direct sum with the +graded tensor product of the two fermionic algebras. Applied repeatedly it exhibits the jet +algebra as the exterior product of the five species algebras, peeling off one species — all +three of its generations at once — at a time. It has to be stated one species at a time: +`GradedTensorProduct` carries no `GradedAlgebra` instance in Mathlib, so the fully nested +five-fold graded tensor product is not expressible as a type. + +-/ + +open scoped TensorProduct + +/-- The fermionic jet algebra as the exterior product of the three-generation + lepton-doublet algebra with the algebra of the remaining four species. -/ +noncomputable def exteriorProductLeptonDoublet : + FermionJetAlgebra ≃ₐ[ℂ] (FermionicAlgebra.evenOdd (Fin 3 → LeptonDoublet) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd ((Fin 3 → LeptonSinglet) × (Fin 3 → QuarkDoublet) × + (Fin 3 → UpSinglet) × (Fin 3 → DownSinglet))) := + FermionicAlgebra.prodEquiv _ _ + +/-- The charged-lepton singlets split off the remaining three species. -/ +noncomputable def exteriorProductLeptonSinglet : + FermionicAlgebra ((Fin 3 → LeptonSinglet) × (Fin 3 → QuarkDoublet) × + (Fin 3 → UpSinglet) × (Fin 3 → DownSinglet)) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (Fin 3 → LeptonSinglet) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd ((Fin 3 → QuarkDoublet) × (Fin 3 → UpSinglet) × + (Fin 3 → DownSinglet))) := + FermionicAlgebra.prodEquiv _ _ + +/-- The quark doublets split off the two quark singlets. -/ +noncomputable def exteriorProductQuarkDoublet : + FermionicAlgebra ((Fin 3 → QuarkDoublet) × (Fin 3 → UpSinglet) × + (Fin 3 → DownSinglet)) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (Fin 3 → QuarkDoublet) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd ((Fin 3 → UpSinglet) × (Fin 3 → DownSinglet))) := + FermionicAlgebra.prodEquiv _ _ + +/-- The two quark singlets as an exterior product. -/ +noncomputable def exteriorProductUpSinglet : + FermionicAlgebra ((Fin 3 → UpSinglet) × (Fin 3 → DownSinglet)) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd (Fin 3 → UpSinglet) ᵍ⊗[ℂ] + FermionicAlgebra.evenOdd (Fin 3 → DownSinglet)) := + FermionicAlgebra.prodEquiv _ _ + +/-! + +### B.3. The actions on the fermionic jet algebra + +-/ + +open Matrix MatrixGroups in +/-- The Lorentz action on the fermionic jet algebra of the Standard Model. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) FermionJetAlgebra := + FermionicAlgebra.repLorentzGroup FermionSpace.repLorentzGroup + +/-- The jet gauge action on the fermionic jet algebra of the Standard Model. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI FermionJetAlgebra := + FermionicAlgebra.repJetGaugeGroupI FermionSpace.repJetGaugeGroupI + FermionSpace.repJetGaugeGroupI_smul + +/-- The global gauge action on the fermionic jet algebra of the Standard Model. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI FermionJetAlgebra := + FermionicAlgebra.repGaugeGroupI FermionSpace.repJetGaugeGroupI + FermionSpace.repJetGaugeGroupI_smul + +/-! + +### B.4. The mass-dimension scaling + +-/ + +/-- The mass-dimension scaling on the fermionic jet algebra: every Standard Model fermion + has mass dimension `3/2`, that is mass weight three, and each derivative adds mass + weight two. -/ +noncomputable def massWeightScale (c : ℂ) : FermionJetAlgebra →ₐ[ℂ] FermionJetAlgebra := + FermionicAlgebra.massWeightScale 3 c + +end FermionJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean index 1c85c5e09..29d813884 100644 --- a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean +++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet.lean @@ -6,7 +6,12 @@ Authors: Nathaneal Sajan module public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps /-! # Lepton doublets @@ -42,6 +47,7 @@ form of the Standard Model gauge group. - D. Gauge action - E. Kernel of the gauge action - F. Descent to quotient gauge groups +- G. Jet gauge action -/ @@ -109,6 +115,21 @@ lemma val_smul (r : ℂ) (l : LeptonDoublet) : (r • l).val = r • l.val := rf /-! +## The basis of the lepton-doublet space + +-/ + +/-- A basis on the lepton doublets. -/ +noncomputable def basis : Module.Basis (Fin 2 × Fin 2) ℂ LeptonDoublet := + (Fermion.LeftHandedWeyl.basis.tensorProduct + (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis).map valLinEquiv.symm + +instance : Module.Finite ℂ LeptonDoublet := Module.Finite.of_basis basis + +instance : Module.Free ℂ LeptonDoublet := Module.Free.of_basis basis + +/-! + ## C. Lorentz action The Lorentz group acts on the left-handed Weyl factor and leaves the weak index fixed. @@ -293,6 +314,199 @@ noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂) | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃) +/-! + +## G. Jet gauge action + +The `(1, 2)_{-3}` representation extends verbatim to jets, in the same way as for the +quark singlets: the jet ring is absorbed into the weak index, and the `SU(2)` +power-series matrix of a jet of gauge transformations, scaled by the hypercharge power +series `star u ^ 3`, acts `JetRing`-linearly on the weak factor. On jets of constant +gauge transformations the action reduces to the global gauge action. + +-/ + +@[simp] +lemma mk_zero : (⟨0⟩ : LeptonDoublet) = 0 := rfl + +/-- Absorbs the jet ring into the weak index: a jet of a lepton doublet is the same +thing as a left-handed Weyl spinor tensored with a `JetRing`-valued weak vector, + + `JetRing ⊗[ℂ] LeptonDoublet ≃ LeftHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 2)`. + +-/ +noncomputable def jetValLinEquiv : + JetRing ⊗[ℂ] LeptonDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ JetRing Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 2))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.LeftHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) + (WithLp.linearEquiv 2 ℂ (Fin 2 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ JetRing JetRing (Fin 2)).trans + (WithLp.linearEquiv 2 JetRing (Fin 2 → JetRing)).symm).restrictScalars ℂ + +/-- The `(1, 2)_{-3}` action of the jet gauge group on the jet space of the lepton +doublet. Through `jetValLinEquiv` the weak matrix of the gauge jet, carrying the `-3` +hypercharge phase `(star u) ^ 3`, acts `JetRing`-linearly on the weak factor by +matrix-vector multiplication, while the Weyl factor is untouched. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] LeptonDoublet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 2)) Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End JetRing (EuclideanSpace JetRing (Fin 2))).restrictScalars ℂ + = 1 := rfl + rw [show (((star (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing)) ^ 3) • + (((1 : JetGaugeGroupI).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) = 1 from by simp, + map_one, hres, map_one] + ext d x + simp [-valLinEquiv_apply] + map_mul' U₁ U₂ := by + have hres : ∀ f g : Module.End JetRing (EuclideanSpace JetRing (Fin 2)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + have hM : (((star (((U₁ * U₂).2.2 : unitary JetRing) : JetRing)) ^ 3) • + (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) = + (((star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U₁.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) * + (((star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U₂.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) := by + rw [show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, + show (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) = + ((U₁.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) * + ((U₂.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + from rfl, + star_mul', mul_pow, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + rw [hM, map_mul, hres, map_mul] + ext d x + simp + +/-- The identification of the jets of the lepton doublet intertwines multiplication by +a scalar jet with the `JetRing`-scalar action on the weak coordinates. -/ +lemma jetValLinEquiv_smul (χ : JetRing) (z : JetRing ⊗[ℂ] LeptonDoublet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 2)) χ).restrictScalars ℂ) + (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, map_add] + | tmul f x => + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : LeptonDoublet) = 0 from rfl, TensorProduct.tmul_zero, + smul_zero, map_zero, map_zero] + | tmul ψ c => + rw [TensorProduct.smul_tmul', smul_eq_mul, + show jetValLinEquiv ((χ * f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (χ * f)) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + show Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 2)) χ).restrictScalars ℂ) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f)) + = ψ ⊗ₜ[ℂ] (χ • WithLp.toLp 2 fun i => c.ofLp i • f) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show c.ofLp i • (χ * f) = χ * (c.ofLp i • f) + rw [Algebra.mul_smul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : LeptonDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, smul_add, map_add, ha, hb, map_add, map_add] + +/-- **The jet gauge action on the jets of the lepton doublet is fibrewise**: it commutes +with multiplication by scalar jets. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] LeptonDoublet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End JetRing (EuclideanSpace JetRing (Fin 2)) := + LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 2)) χ with hS + set M : Module.End JetRing (EuclideanSpace JetRing (Fin 2)) := + (Matrix.toLpLinAlgEquiv 2 + (((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) : + Module.End JetRing (EuclideanSpace JetRing (Fin 2))) with hM + have hMS : M * S = S * M := LinearMap.ext fun e => by + simp only [Module.End.mul_apply, hS, LinearMap.lsmul_apply, map_smul] + apply jetValLinEquiv.injective + rw [show repJetGaugeGroupI U (χ • z) + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.LeftHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv (χ • z))) from rfl, + LinearEquiv.apply_symm_apply, jetValLinEquiv_smul, + show repJetGaugeGroupI U z + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.LeftHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv z)) from rfl, + jetValLinEquiv_smul, LinearEquiv.apply_symm_apply, ← Module.End.mul_apply, + ← Module.End.mul_apply, ← map_mul, ← map_mul, + show M.restrictScalars ℂ * S.restrictScalars ℂ = (M * S).restrictScalars ℂ from rfl, + show S.restrictScalars ℂ * M.restrictScalars ℂ = (S * M).restrictScalars ℂ from rfl, + hMS] + +/-- On jets of constant gauge transformations the jet action reduces to the global +gauge action on the fibre: the `(1, 2)_{-3}` action on the lepton-doublet factor, and +the trivial action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext d x + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => simp [show ({ val := 0 } : LeptonDoublet) = 0 from rfl] + | tmul psi c => + apply jetValLinEquiv.injective + simp [repJetGaugeGroupI, jetValLinEquiv, repGaugeGroupI] + have hu : star (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((starRingEnd ℂ) (g.toU1.1 : ℂ)) := by + rw [show (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) from rfl, JetRing.star_C] + rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).2.1 : + specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) i j + = MvPowerSeries.C (g.toSU2.1 i j) := fun _ _ => rfl + have halg : ∀ A : Matrix (Fin 2) (Fin 2) JetRing, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End JetRing (EuclideanSpace JetRing (Fin 2))) + = Matrix.toLpLin 2 2 A := fun _ => rfl + have hvec : ∀ i : Fin 2, + (∑ x, MvPowerSeries.C ((g.toSU2.1) i x) * (MvPowerSeries.C (c.ofLp x) * d)) + = MvPowerSeries.C (∑ x, (g.toSU2.1) i x * c.ofLp x) * d := by + intro i + rw [map_sum, Finset.sum_mul] + exact Finset.sum_congr rfl fun x _ => by rw [← mul_assoc, ← map_mul] + rw [TensorProduct.liftAux_tmul, ← TensorProduct.tmul_smul] + simp only [LinearMap.compl₂_apply, TensorProduct.mk_apply, LinearMap.smul_apply, + LinearMap.restrictScalars_apply, halg, Matrix.toLpLin_toLp] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + simp only [WithLp.ofLp_smul, Pi.smul_apply, Matrix.toLin'_apply, + Matrix.mulVec_apply_eq_sum, hM, Algebra.smul_def, MvPowerSeries.algebraMap_apply, + hu, map_pow, Algebra.algebraMap_self_apply] + rw [hvec i] + | add a b ha hb => + simp only [show ({ val := a + b } : LeptonDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + map_add, ha, hb] + end LeptonDoublet end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/GaugeAlgebraAction.lean new file mode 100644 index 000000000..a5dcfce64 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonDoublet/GaugeAlgebraAction.lean @@ -0,0 +1,649 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! +# The infinitesimal gauge action on the lepton doublet + +## i. Overview + +The infinitesimal `(1, 2)_{-3}` action of the gauge algebra on the lepton doublet: the +weak part of the algebra element acts on the weak index and the hypercharge part scales, +both through the physicists' factor of `i`, matching the group action +`(star u) ^ 3 • U₂` infinitesimally. The compatibility with the jet gauge action — +`GaugeAlgebra.IsInfinitesimalActionOf` — is proved at the end of this file: the +base-point Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law +and intertwine the action with the adjoint transports. The proofs work through the weak +matrix of the jet action and the all-orders matrix Leibniz rule at the base point. + +## ii. Key results + +- `weakEnd` : the endomorphism of the lepton doublet defined by a `2 × 2` matrix on the + weak index. +- `gaugeAlgebraAction` : the infinitesimal `(1, 2)_{-3}` action of the gauge algebra. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action `repJetGaugeGroupI`. + +## iii. Table of contents + +- A. The action of the gauge algebra +- B. The infinitesimal action underlies the jet gauge action + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +namespace LeptonDoublet + +open Matrix MatrixGroups + +/-! + +## A. The action of the gauge algebra + +-/ + +/-- The endomorphism of the lepton doublet defined by a `2 × 2` complex matrix acting on + the weak index, with the Weyl factor untouched. -/ +noncomputable def weakEnd (A : Matrix (Fin 2) (Fin 2) ℂ) : + LeptonDoublet →ₗ[ℂ] LeptonDoublet := + valLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 2)) Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) ∘ₗ valLinEquiv.toLinearMap + +lemma weakEnd_apply_mk (A : Matrix (Fin 2) (Fin 2) ℂ) (v : LeptonDoublet) : + weakEnd A v + = valLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 2)) Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) (valLinEquiv v)) := rfl + +lemma weakEnd_add (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A + B) = weakEnd A + weakEnd B := by + rw [weakEnd, weakEnd, weakEnd, map_add, map_add, LinearMap.add_comp, + LinearMap.comp_add] + +lemma weakEnd_smul (z : ℂ) (A : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (z • A) = z • weakEnd A := by + rw [weakEnd, weakEnd, map_smul, map_smul, LinearMap.smul_comp, + LinearMap.comp_smul] + +lemma weakEnd_zero : weakEnd 0 = 0 := by + rw [weakEnd, map_zero, map_zero, LinearMap.zero_comp, LinearMap.comp_zero] + +lemma weakEnd_neg (A : Matrix (Fin 2) (Fin 2) ℂ) : weakEnd (-A) = -weakEnd A := by + rw [show (-A : Matrix (Fin 2) (Fin 2) ℂ) = (-1 : ℂ) • A from by rw [neg_one_smul], + weakEnd_smul, neg_one_smul] + +lemma weakEnd_multiset_sum (m : Multiset (Matrix (Fin 2) (Fin 2) ℂ)) : + weakEnd m.sum = (m.map weakEnd).sum := by + induction m using Multiset.induction_on with + | empty => simp [weakEnd_zero] + | cons A t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + weakEnd_add, ih] + +/-- The weak endomorphisms compose through matrix multiplication. -/ +lemma weakEnd_mul (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A * B) = weakEnd A ∘ₗ weakEnd B := by + refine LinearMap.ext fun v => ?_ + rw [weakEnd_apply_mk, map_mul, map_mul, LinearMap.comp_apply, weakEnd_apply_mk, + weakEnd_apply_mk, LinearEquiv.apply_symm_apply] + rfl + +/-- The matrix of the infinitesimal `(1, 2)_{-3}` action of a gauge algebra element on + the weak index: `i` times the weak part, shifted by `i` times `-3` the + hypercharge. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : Matrix (Fin 2) (Fin 2) ℂ := + Complex.I • (c.toSU2Matrix - ((3 : ℂ) • c.toU1Value) • 1) + +/-- **The infinitesimal action of the gauge algebra on the lepton doublet**: the + derivative of the `(1, 2)_{-3}` action of the gauge group, real-linear in the + algebra slot and complex-linear in the value slot — the form consumed by the + covariant derivative `IsGaugeField.covDerivIter` and by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] LeptonDoublet →ₗ[ℂ] LeptonDoublet where + toFun c := weakEnd (actionMatrix c) + map_add' c₁ c₂ := by + rw [show actionMatrix (c₁ + c₂) = actionMatrix c₁ + actionMatrix c₂ from by + rw [actionMatrix, actionMatrix, actionMatrix, GaugeAlgebra.add_toSU2Matrix, + GaugeAlgebra.add_toU1Value] + module] + rw [weakEnd_add] + map_smul' r c := by + rw [show actionMatrix (r • c) = (r : ℂ) • actionMatrix c from by + rw [actionMatrix, actionMatrix, GaugeAlgebra.smul_toSU2Matrix, + GaugeAlgebra.smul_toU1Value, + show (r • c.toSU2Matrix : Matrix (Fin 2) (Fin 2) ℂ) + = (r : ℂ) • c.toSU2Matrix from by + rw [← algebraMap_smul ℂ r c.toSU2Matrix]; rfl, + show r • c.toU1Value = (r : ℂ) • c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value]; rfl] + module, + weakEnd_smul] + refine LinearMap.ext fun v => ?_ + rw [RingHom.id_apply] + show (r : ℂ) • weakEnd (actionMatrix c) v = r • weakEnd (actionMatrix c) v + rw [show ((r : ℝ) : ℂ) = algebraMap ℝ ℂ r from rfl, algebraMap_smul] + +/-! + +## B. The infinitesimal action underlies the jet gauge action + +The `(1, 2)_{-3}` action of the gauge algebra is the infinitesimal action underlying the +jet gauge action, in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`: the base-point +Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law and +intertwine the action with the adjoint transports. The proofs work through the weak +matrix of the jet action and the all-orders matrix Leibniz rule at the base point. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : JetRing) : + pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) f) + = x.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, ih, JetRing.pderiv_comm] + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The iterated formal derivative of a difference. -/ +private lemma foldl_pderiv_sub (x : Multiset (Fin 1 ⊕ Fin 3)) (f g : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (f - g) + = x.foldl (fun h ρ => pderiv ℂ ρ h) f - x.foldl (fun h ρ => pderiv ℂ ρ h) g := by + induction x using Multiset.induction_on generalizing f g with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_sub, ih, Multiset.foldl_cons, + Multiset.foldl_cons] + +/-- The jet-valued matrix of the infinitesimal `(1, 2)_{-3}` action of a jet of gauge + algebra elements: the jet analogue of `actionMatrix`. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : Matrix (Fin 2) (Fin 2) JetRing := + Complex.I • (a.toSU2Matrix - ((3 : ℂ) • a.toU1Value) • 1) + +/-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ +lemma jetActionMatrix_map_cc_foldl (p : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + ((jetActionMatrix a).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := by + ext i j + rw [Matrix.map_apply, jetActionMatrix, actionMatrix, Matrix.smul_apply, + Matrix.sub_apply, Matrix.smul_apply, Matrix.smul_apply, Matrix.sub_apply, + Matrix.smul_apply, foldl_pderiv_smul, constantCoeff_smul, foldl_pderiv_sub, + map_sub, JetGaugeAlgebra.eval_iteratedDeriv_toSU2Matrix, Matrix.map_apply] + congr 2 + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq, smul_eq_mul, mul_one, smul_eq_mul, + mul_one, foldl_pderiv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + JetRing.foldl_pderiv_zero, map_zero] + +/-- The `JetRing`-valued weak matrix of the jet gauge action on the lepton doublet: the + weak matrix of the gauge jet carrying the `-3` hypercharge phase. -/ +noncomputable def doubletMatrix (U : JetGaugeGroupI) : Matrix (Fin 2) (Fin 2) JetRing := + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + +lemma repJetGaugeGroupI_eq_doubletMatrix (U : JetGaugeGroupI) + (z : JetRing ⊗[ℂ] LeptonDoublet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)).restrictScalars ℂ) + (jetValLinEquiv z)) := rfl + +/-- The entrywise formal derivative on the weak coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivWeak (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace JetRing (Fin 2) where + toFun v := WithLp.toLp 2 fun i => pderiv ℂ μ (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact Derivation.map_smul _ _ _ + +/-- The entrywise iterated formal derivative on the weak coordinates. -/ +private noncomputable def foldWeak (x : Multiset (Fin 1 ⊕ Fin 3)) : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace JetRing (Fin 2) where + toFun v := WithLp.toLp 2 fun i => x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact JetRing.foldl_pderiv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact foldl_pderiv_smul x z _ + +/-- The entrywise base-point evaluation on the weak coordinates. -/ +private noncomputable def ccWeak : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun v := WithLp.toLp 2 fun i => constantCoeff (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact constantCoeff_smul _ _ + +private lemma pderivWeak_comp_foldWeak (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivWeak μ ∘ₗ foldWeak x = foldWeak (μ ::ₘ x) := by + refine LinearMap.ext fun v => ?_ + refine WithLp.ofLp_injective 2 ?_ + funext i + show pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i)) + = (μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + rw [Multiset.foldl_cons, pderiv_foldl] + +/-- The identification of lepton-doublet jets intertwines the formal derivative with the + entrywise derivative on the weak coordinates. -/ +private lemma jetValLinEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (z : JetRing ⊗[ℂ] LeptonDoublet) : + jetValLinEquiv (StandardModel.jetDeriv μ z) + = (TensorProduct.map LinearMap.id (pderivWeak μ)) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : LeptonDoublet) = 0 from rfl, TensorProduct.tmul_zero, + map_zero, map_zero, map_zero] + | tmul ψ c => + rw [show StandardModel.jetDeriv μ (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = (pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet) from rfl, + show jetValLinEquiv ((pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • pderiv ℂ μ f) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + exact (Derivation.map_smul (pderiv ℂ μ) (c.ofLp i) f).symm + | add a b ha hb => + rw [show ({ val := a + b } : LeptonDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +/-- The identification of lepton-doublet jets intertwines the iterated formal derivative + with the entrywise iterated derivative on the weak coordinates. -/ +private lemma jetValLinEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) + (z : JetRing ⊗[ℂ] LeptonDoublet) : + jetValLinEquiv (StandardModel.jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldWeak x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [StandardModel.jetIteratedDeriv_zero, LinearMap.id_apply, + show foldWeak 0 = LinearMap.id from LinearMap.ext fun v => + WithLp.ofLp_injective 2 rfl, + TensorProduct.map_id, LinearMap.id_apply] + | cons μ t ih => + rw [StandardModel.jetIteratedDeriv_cons, LinearMap.comp_apply, + jetValLinEquiv_jetDeriv, ih, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, pderivWeak_comp_foldWeak] + +/-- The base-point evaluation of a lepton-doublet jet through the weak coordinates. -/ +private lemma valLinEquiv_jetEval (z : JetRing ⊗[ℂ] LeptonDoublet) : + valLinEquiv (StandardModel.jetEval z) + = (TensorProduct.map LinearMap.id ccWeak) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp; rfl + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : LeptonDoublet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rfl + | tmul ψ c => + rw [StandardModel.jetEval_tmul, map_smul, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet) = ψ ⊗ₜ[ℂ] c from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply, ← TensorProduct.tmul_smul] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show (constantCoeff f • c).ofLp i = constantCoeff (c.ofLp i • f) + simp [constantCoeff_smul, mul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : LeptonDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +set_option maxHeartbeats 1000000 in +/-- **The derivative identity** for the weak matrix of the jet gauge action: the + formal derivative of the weak matrix is minus the jet action matrix of the + Maurer–Cartan form times the weak matrix. -/ +lemma doubletMatrix_map_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (doubletMatrix U).map (fun f => pderiv ℂ μ f) + = -(jetActionMatrix (maurerCartanForm U μ) * doubletMatrix U) := by + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + have h0 : pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) = 0 := by + have h := congrArg (pderiv ℂ μ) huu + rw [hleib, Derivation.map_one_eq_zero] at h + exact h + have hsu : pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) + = -(pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * (star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing))) := by + have h1 : star ((U.2.2 : unitary JetRing) : JetRing) + * (pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) * huu + have hm₂U₂ : (maurerCartanForm U μ).toSU2Matrix * U.2.1.1 + = Complex.I • U.2.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU2Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₂u, + Matrix.mul_one] + have hiC : (algebraMap ℂ JetRing) Complex.I * (algebraMap ℂ JetRing) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : ((((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)).map fun f => pderiv ℂ μ f) + = (pderiv ℂ μ ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3)) • U.2.1.1 + + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) + • (U.2.1.1.map (pderiv ℂ μ)) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul] + exact hleib _ _ + rw [doubletMatrix, jetActionMatrix, hmap, Matrix.smul_mul, Matrix.sub_mul, + Matrix.mul_smul, hm₂U₂, Matrix.smul_mul, Matrix.one_mul, + smul_comm ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) Complex.I, + smul_sub, smul_smul Complex.I Complex.I, Complex.I_mul_I, neg_one_smul, + ← smul_assoc, neg_sub, sub_neg_eq_add, smul_smul] + congr 1 + congr 1 + rw [maurerCartanForm_toU1Value, + show (star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3 + = (star ((U.2.2 : unitary JetRing) : JetRing)) + * (star ((U.2.2 : unitary JetRing) : JetRing)) + * (star ((U.2.2 : unitary JetRing) : JetRing)) from by ring, + hleib, hleib, hsu, Algebra.smul_def, Algebra.smul_def, Algebra.smul_def, + map_ofNat] + linear_combination (-(3 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing))) * hiC + +/-- **The equivariance identity** for the weak matrix of the jet gauge action: the + weak matrix intertwines the constant jet action matrix with its adjoint + transform. -/ +lemma doubletMatrix_mul_jetActionMatrix (U : JetGaugeGroupI) (c : GaugeAlgebra) : + doubletMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = jetActionMatrix (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c)) + * doubletMatrix U := by + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rw [doubletMatrix, jetActionMatrix, jetActionMatrix, + JetGaugeAlgebra.adjointMap_toSU2Matrix, JetGaugeAlgebra.adjointMap_toU1Value] + conv_lhs => rw [Matrix.mul_smul, Matrix.smul_mul, Matrix.mul_sub, Matrix.mul_smul, + Matrix.mul_one] + conv_rhs => rw [Matrix.smul_mul, Matrix.sub_mul, Matrix.mul_smul, + Matrix.smul_mul, Matrix.one_mul, Matrix.mul_assoc, hU₂u, Matrix.mul_one] + rw [smul_sub, smul_comm ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 3) + ((3 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +set_option maxHeartbeats 1000000 in +/-- **The base-point Taylor coefficients of the jet gauge action** on the lepton + doublet are the weak endomorphisms of the base-point Taylor coefficients of the + weak matrix. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = weakEnd ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x d + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + weakEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_doubletMatrix, LinearEquiv.apply_symm_apply, + StandardModel.jetOfConstant_apply] + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : LeptonDoublet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rw [show (0 : LeptonDoublet).val = 0 from rfl, map_zero] + | add a b ha hb => + rw [show ({ val := a + b } : LeptonDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, map_add, map_add, ha, hb, map_add, + map_add] + | tmul ψ c => + rw [show jetValLinEquiv ((1 : JetRing) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) from rfl, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : LeptonDoublet) = ψ ⊗ₜ[ℂ] c from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 2)) + Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (doubletMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j + = ∑ k, doubletMatrix U j k * (c.ofLp k • (1 : JetRing)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + = ∑ k, constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (doubletMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + JetRing.foldl_pderiv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + mul_comm] + + +/-- The weak endomorphism of the identity matrix is the identity. -/ +lemma weakEnd_one : weakEnd 1 = LinearMap.id := by + refine LinearMap.ext fun v => ?_ + rw [weakEnd_apply_mk, map_one, map_one, Module.End.one_apply, + LinearEquiv.symm_apply_apply, LinearMap.id_apply] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h2 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((doubletMatrix U).map fun f => + constantCoeff ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, Multiset.foldl_zero, doubletMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, JetRing.constantCoeff_star, hu, star_one, + one_pow, one_mul] + exact Matrix.ext_iff.mpr h2 i j + rw [repCoeff_eq, hM, weakEnd_one] + +set_option maxHeartbeats 1000000 in +/-- **The `(1, 2)_{-3}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the lepton doublet**: its base-point Taylor + coefficients obey the Maurer–Cartan Leibniz law and intertwine the action with the + adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : ((doubletMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((doubletMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum) := by + rw [show ((doubletMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (((doubletMatrix U).map fun f => pderiv ℂ μ f).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + Multiset.foldl_cons], + doubletMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * doubletMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * doubletMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, foldl_pderiv_neg, map_neg], + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [jetActionMatrix_map_cc_foldl])) + rw [repCoeff_eq, hMcons, weakEnd_neg, weakEnd_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, weakEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hCsmul : ∀ z w : ℂ, (z • (C w : JetRing)) = C (z * w) := fun z w => by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + Algebra.algebraMap_self_apply, ← map_mul] + have hconst : jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = (actionMatrix c).map (C : ℂ → JetRing) := by + refine Matrix.ext fun i j => ?_ + rw [jetActionMatrix, actionMatrix, JetGaugeAlgebra.ofConstant_toSU2Matrix, + JetGaugeAlgebra.ofConstant_toU1Value, Matrix.map_apply, Matrix.smul_apply, + Matrix.sub_apply, Matrix.map_apply, Matrix.smul_apply, Matrix.smul_apply, + Matrix.sub_apply, Matrix.smul_apply] + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq] + simp only [smul_eq_mul, mul_one] + rw [hCsmul, ← map_sub, hCsmul] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + sub_zero, sub_zero, hCsmul] + exact congrArg C (by ring) + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((actionMatrix c).map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then actionMatrix c else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, constantCoeff_C] + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (IsGaugeField.adjointCoeff U p.1 c) + * ((doubletMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have h1 : ((doubletMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c := by + rw [hconst, matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((doubletMatrix U).map fun f => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p hp => by rw [if_neg hp, Matrix.mul_zero]), + if_pos rfl] + rw [← h1, doubletMatrix_mul_jetActionMatrix, matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [jetActionMatrix_map_cc_foldl, + show JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c))) + = IsGaugeField.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (weakEnd ((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + ∘ₗ gaugeAlgebraAction c + = weakEnd (((doubletMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c) from by + rw [weakEnd_mul]; rfl, + hMact, weakEnd_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, weakEnd_mul, repCoeff_eq] + rfl + +end InfinitesimalAction + +end LeptonDoublet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSector/Basic.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSector/Basic.lean new file mode 100644 index 000000000..4c74b650e --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSector/Basic.lean @@ -0,0 +1,15 @@ +/-! + +## Lepton sector + +We consider the lepton sector, which consits +of the Lepton doublet and lepton singlet, as well as the higgs. + +We will show in a very general setting, the yukawa terms allowed +in the lepton sector. + +In this file we define: +- The vector Letpon sector vector space, the action of the gauge group on it, + and the Lorentz group. + +-/ diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean similarity index 55% rename from Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean rename to Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean index 85ccb50e6..37796b232 100644 --- a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/Basic.lean @@ -6,7 +6,10 @@ Authors: Nathaneal Sajan module public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.DerivAlgebra +public import Physlib.Mathematics.ConjModule /-! # Charged-lepton singlets @@ -37,8 +40,9 @@ form of the Standard Model gauge group. - A. The charged-lepton-singlet space - B. Linear structure + - B.1. The basis of the charged-lepton-singlet space - C. Lorentz action -- D. Gauge action +- D. Global Gauge action - E. Kernel of the gauge action - F. Descent to quotient gauge groups @@ -104,6 +108,20 @@ lemma val_smul (r : ℂ) (l : LeptonSinglet) : (r • l).val = r • l.val := rf /-! +### B.1. The basis of the charged-lepton-singlet space + +-/ + +/-- A basis on the charged-lepton singlets. -/ +noncomputable def basis : Module.Basis (Fin 2) ℂ LeptonSinglet := + Fermion.RightHandedWeyl.basis.map valLinEquiv.symm + +instance : Module.Finite ℂ LeptonSinglet := Module.Finite.of_basis basis + +instance : Module.Free ℂ LeptonSinglet := Module.Free.of_basis basis + +/-! + ## C. Lorentz action The Lorentz group acts through the right-handed Weyl representation, transported along the @@ -122,9 +140,44 @@ noncomputable def repLorentzGroup : Representation ℂ (SL(2,ℂ)) LeptonSinglet ext1 l simp [Module.End.mul_eq_comp] +/-- The Lorentz action on the lepton-singlet basis: the right-handed Weyl + action by the entrywise conjugate matrix. -/ +lemma repLorentzGroup_apply_basis (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup Λ (basis α) = ∑ β, star (Λ.1 β α) • basis β := by + simp only [basis, Module.Basis.map_apply, repLorentzGroup, MonoidHom.coe_mk, + OneHom.coe_mk, LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply, + LinearEquiv.apply_symm_apply, Fermion.RightHandedWeyl.rep_apply_basis, + Matrix.map_apply, map_sum, map_smul] + +/-- The lepton jet coordinates transform contragrediently, by the entrywise + conjugate of the inverse matrix. -/ +lemma repLorentzGroup_dual_dualBasis (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup.dual Λ (basis.dualBasis α) = + ∑ β, star ((Λ⁻¹).1 α β) • basis.dualBasis β := + Representation.dual_apply_dualBasis _ _ _ _ + (Matrix.of fun l j => star ((Λ⁻¹).1 l j)) + (fun j => repLorentzGroup_apply_basis Λ⁻¹ j) + +/-- The Lorentz action on the conjugate lepton basis: the coefficients are the + conjugates of those of the lepton action, that is, the matrix itself. -/ +lemma repLorentzGroup_conj_apply_basis (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup.conj Λ (basis.conj α) = ∑ β, Λ.1 β α • basis.conj β := by + rw [Representation.conj_apply, Module.Basis.conj_apply, + LinearEquiv.symm_apply_apply, repLorentzGroup_apply_basis, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [LinearEquiv.map_smulₛₗ, starRingEnd_apply, star_star, Module.Basis.conj_apply] + +/-- The conjugate lepton jet coordinates transform by the inverse matrix. -/ +lemma repLorentzGroup_conj_dual_dualBasis (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup.conj.dual Λ (basis.conj.dualBasis α) = + ∑ β, (Λ⁻¹).1 α β • basis.conj.dualBasis β := + Representation.dual_apply_dualBasis _ _ _ _ + (Matrix.of fun l j => (Λ⁻¹).1 l j) + (fun j => repLorentzGroup_conj_apply_basis Λ⁻¹ j) + /-! -## D. Gauge action +## D. Global Gauge action The colour and weak factors act trivially, so the gauge group acts only through hypercharge. The `U(1)` action is `star z ^ 6`; since `z` is unitary, `star z = z⁻¹`, so this represents @@ -221,6 +274,86 @@ noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂) | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃) +/-! + +## G. The representation of the jet gauge group + +The charged-lepton singlet carries no colour or weak index, so a jet of gauge +transformations acts on its jets purely through the hypercharge power series +`(star u) ^ 6`, multiplying the jet-ring factor and leaving the Weyl factor untouched. + +-/ + +open TensorProduct in +/-- The `(1, 1)_{-6}` action of the jet gauge group on the jet space of the charged-lepton +singlet: multiplication of the jet-ring factor by the hypercharge power series +`(star u) ^ 6`. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] LeptonSinglet) where + toFun U := LinearMap.rTensor LeptonSinglet + (LinearMap.mulLeft ℂ ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6)) + map_one' := by + rw [show (star (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing)) ^ 6 + = 1 from by simp, LinearMap.mulLeft_one, LinearMap.rTensor_id] + rfl + map_mul' U₁ U₂ := by + rw [show (star (((U₁ * U₂).2.2 : unitary JetRing) : JetRing)) ^ 6 + = (star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 6 + * (star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 6 from by + rw [show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) + = ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, star_mul', mul_pow, mul_comm], + show LinearMap.mulLeft ℂ + ((star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 6 + * (star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 6) + = (LinearMap.mulLeft ℂ ((star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 6)) ∘ₗ + (LinearMap.mulLeft ℂ ((star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 6)) from + LinearMap.ext fun z => mul_assoc _ _ z, + LinearMap.rTensor_comp] + rfl + +open TensorProduct in +/-- The jet gauge action on a pure tensor of the jet space of the charged-lepton +singlet. -/ +lemma repJetGaugeGroupI_tmul (U : JetGaugeGroupI) (f : JetRing) (ψ : LeptonSinglet) : + repJetGaugeGroupI U (f ⊗ₜ[ℂ] ψ) + = ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6 * f) ⊗ₜ[ℂ] ψ := + LinearMap.rTensor_tmul _ _ _ _ + +open TensorProduct in +/-- **The jet gauge action on the jets of the charged-lepton singlet is fibrewise**: it +commutes with multiplication by scalar jets. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] LeptonSinglet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, smul_add] + | tmul f ψ => + rw [TensorProduct.smul_tmul', smul_eq_mul, repJetGaugeGroupI_tmul, + repJetGaugeGroupI_tmul, TensorProduct.smul_tmul', smul_eq_mul, mul_left_comm] + +open TensorProduct in +/-- On jets of constant gauge transformations the jet action reduces to the global +gauge action on the fibre: the `(1, 1)_{-6}` action on the lepton-singlet factor, and +the trivial action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext f x + obtain ⟨ψ⟩ := x + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + simp only [TensorProduct.AlgebraTensorModule.curry_apply, TensorProduct.curry_apply, + LinearMap.restrictScalars_apply, repJetGaugeGroupI_tmul, hu, JetRing.star_C, ← map_pow, + TensorProduct.map_tmul, LinearMap.id_apply, repGaugeGroupI_apply] + rw [show (⟨(star (g.toU1.1 : ℂ) ^ 6) • ψ⟩ : LeptonSinglet) + = (star (g.toU1.1 : ℂ) ^ 6) • (⟨ψ⟩ : LeptonSinglet) from rfl, + TensorProduct.tmul_smul, + show (MvPowerSeries.C (star (g.toU1.1 : ℂ) ^ 6) * f) = (star (g.toU1.1 : ℂ) ^ 6) • f from + by rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, Algebra.algebraMap_self_apply], + TensorProduct.smul_tmul'] + end LeptonSinglet end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/GaugeAlgebraAction.lean new file mode 100644 index 000000000..2784dce3c --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,326 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +/-! +# The gauge-algebra action on the charged-lepton singlet + +## i. Overview + +The charged-lepton singlet carries the `(1, 1)_{-6}` representation of the gauge group, +so the infinitesimal action of the gauge algebra is scalar: multiplication by +`i` times `-6` times the `u(1)` value of the algebra element. This file defines that +action and proves it is the infinitesimal action underlying the jet gauge action, in +the sense of `GaugeAlgebra.IsInfinitesimalActionOf`. + +Because the singlet has no colour or weak index, the jet gauge action is multiplication +of the jet-ring factor by the hypercharge phase `(star u) ^ 6`, and both laws of +`IsInfinitesimalActionOf` reduce to scalar identities about the base-point Taylor +coefficients of that phase: the derivative identity `∂ ((star u) ^ 6) = +-(i (-6) ω) (star u) ^ 6` against the `u(1)` value of the Maurer–Cartan form, and the +trivial `u(1)` adjoint equivariance. + +## ii. Key results + +- `gaugeAlgebraAction` : the infinitesimal `(1, 1)_{-6}` action of the gauge algebra. +- `jetPhase` : the hypercharge phase `(star u) ^ 6` of the jet gauge action. +- `repCoeff_eq` : the base-point Taylor coefficients of the jet gauge action are the + base-point Taylor coefficients of the hypercharge phase. +- `jetPhase_pderiv` : the derivative identity for the hypercharge phase. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action. + +## iii. Table of contents + +- A. The infinitesimal action of the gauge algebra +- B. The hypercharge phase of the jet gauge action +- C. The Taylor coefficients of the jet gauge action +- D. The derivative identity for the hypercharge phase +- E. The infinitesimal action underlies the jet gauge action + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +open TensorProduct MvPowerSeries + +/-! + +## A. The infinitesimal action of the gauge algebra + +The `(1, 1)_{-6}` representation acts through the `u(1)` factor alone, so its +derivative is scalar multiplication by `i (-6)` times the `u(1)` value. + +-/ + +/-- **The infinitesimal action of the gauge algebra on the charged-lepton singlet**: + the derivative of the `(1, 1)_{-6}` action of the gauge group — scalar + multiplication by `i` times `-6` times the `u(1)` value, real-linear in the algebra + slot and complex-linear in the value slot — the form consumed by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] LeptonSinglet →ₗ[ℂ] LeptonSinglet where + toFun c := (Complex.I * (-(6 : ℂ) * c.toU1Value)) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) + map_add' c₁ c₂ := by + rw [GaugeAlgebra.add_toU1Value, + show Complex.I * (-(6 : ℂ) * (c₁.toU1Value + c₂.toU1Value)) + = Complex.I * (-(6 : ℂ) * c₁.toU1Value) + + Complex.I * (-(6 : ℂ) * c₂.toU1Value) from by ring, + add_smul] + map_smul' r c := by + rw [GaugeAlgebra.smul_toU1Value, RingHom.id_apply, + show r • c.toU1Value = algebraMap ℝ ℂ r * c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value, smul_eq_mul], + show Complex.I * (-(6 : ℂ) * (algebraMap ℝ ℂ r * c.toU1Value)) + = algebraMap ℝ ℂ r * (Complex.I * (-(6 : ℂ) * c.toU1Value)) from by ring, + mul_smul, algebraMap_smul] + +/-- The gauge-algebra action on the charged-lepton singlet is scalar multiplication + by `i` times `-6` times the `u(1)` value. -/ +lemma gaugeAlgebraAction_apply (c : GaugeAlgebra) : + gaugeAlgebraAction c + = (Complex.I * (-(6 : ℂ) * c.toU1Value)) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := rfl + +/-! + +## B. The hypercharge phase of the jet gauge action + +The jet gauge action multiplies the jet-ring factor by the hypercharge power series +`(star u) ^ 6`: the scalar analogue of the colour matrix of a coloured species. + +-/ + +/-- The `JetRing`-valued hypercharge phase of the jet gauge action on the + charged-lepton singlet: the `-6` hypercharge power series `(star u) ^ 6` of the + gauge jet. -/ +noncomputable def jetPhase (U : JetGaugeGroupI) : JetRing := + (star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6 + +/-- The hypercharge phase, unfolded. -/ +lemma jetPhase_eq (U : JetGaugeGroupI) : + jetPhase U = (star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6 := rfl + +/-- The jet gauge action on the charged-lepton singlet is multiplication of the + jet-ring factor by the hypercharge phase. -/ +lemma repJetGaugeGroupI_eq_jetPhase (U : JetGaugeGroupI) : + repJetGaugeGroupI U + = LinearMap.rTensor LeptonSinglet (LinearMap.mulLeft ℂ (jetPhase U)) := rfl + +/-! + +## C. The Taylor coefficients of the jet gauge action + +-/ + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +/-- The iterated formal derivative of a jet of charged-lepton singlets acts on the + jet-ring factor of a pure tensor. -/ +private lemma jetIteratedDeriv_tmul (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) + (ψ : LeptonSinglet) : + jetIteratedDeriv x (f ⊗ₜ[ℂ] ψ) + = (x.foldl (fun h ρ => pderiv ℂ ρ h) f) ⊗ₜ[ℂ] ψ := by + induction x using Multiset.induction_on generalizing f with + | empty => rw [jetIteratedDeriv_zero]; rfl + | cons μ t ih => + rw [jetIteratedDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_tmul, + Multiset.foldl_cons, JetRing.foldl_pderiv_pderiv] + +/-- Scalar multiples of the identity compose through multiplication. -/ +private lemma smul_id_comp (a b : ℂ) : + (a • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)) + ∘ₗ (b • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)) + = (a * b) • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + refine LinearMap.ext fun l => ?_ + simp [mul_smul] + +/-- A multiset sum of scalar multiples of the identity is the scalar multiple by the + sum. -/ +private lemma sum_map_smul_id {α : Type*} (m : Multiset α) (z : α → ℂ) : + (m.map fun p => z p • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)).sum + = (m.map z).sum • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + induction m using Multiset.induction_on with + | empty => simp + | cons a t ih => + rw [Multiset.map_cons, Multiset.sum_cons, ih, Multiset.map_cons, + Multiset.sum_cons, add_smul] + +/-- **The base-point Taylor coefficients of the jet gauge action** on the + charged-lepton singlet are scalar: multiplication by the base-point Taylor + coefficients of the hypercharge phase. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U)) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + refine LinearMap.ext fun l => ?_ + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x l + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant l))) from rfl, + StandardModel.jetOfConstant_apply, repJetGaugeGroupI_tmul, mul_one, + jetIteratedDeriv_tmul, StandardModel.jetEval_tmul, jetPhase_eq, + LinearMap.smul_apply, LinearMap.id_apply] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + rw [repCoeff_eq, Multiset.foldl_zero, jetPhase_eq, map_pow, + JetRing.constantCoeff_star, hu, star_one, one_pow, one_smul] + + +/-! + +## D. The derivative identity for the hypercharge phase + +-/ + +/-- **The derivative identity** for the hypercharge phase of the jet gauge action: the + formal derivative of the phase is minus `i` times `-6` times the `u(1)` value of the + Maurer–Cartan form, times the phase. -/ +lemma jetPhase_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + pderiv ℂ μ (jetPhase U) + = -(((Complex.I * (-(6 : ℂ))) • (maurerCartanForm U μ).toU1Value) + * jetPhase U) := by + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have h0 : pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) = 0 := by + have h := congrArg (pderiv ℂ μ) huu + rw [hleib, Derivation.map_one_eq_zero] at h + exact h + have hsu : pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) + = -(pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * (star ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing))) := by + have h1 : star ((U.2.2 : unitary JetRing) : JetRing) + * (pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + + ((U.2.2 : unitary JetRing) : JetRing) + * pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing))) = 0 := by + rw [h0, mul_zero] + linear_combination h1 + - pderiv ℂ μ (star ((U.2.2 : unitary JetRing) : JetRing)) * huu + have hiC : (algebraMap ℂ JetRing) Complex.I * (algebraMap ℂ JetRing) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + rw [jetPhase_eq, maurerCartanForm_toU1Value, pderiv_pow, + show (6 : ℕ) - 1 = 5 from rfl, Nat.cast_ofNat, hsu, + Algebra.smul_def, Algebra.smul_def, map_mul, map_neg, map_ofNat] + linear_combination (-(6 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * (star ((U.2.2 : unitary JetRing) : JetRing)) ^ 7)) * hiC + +/-! + +## E. The infinitesimal action underlies the jet gauge action + +Both laws of `GaugeAlgebra.IsInfinitesimalActionOf` reduce through `repCoeff_eq` to +scalar identities: the Maurer–Cartan Leibniz law is the all-orders product rule at the +base point applied to the derivative identity, and the adjoint intertwining collapses +because the adjoint action on the `u(1)` component is trivial. + +-/ + +set_option maxHeartbeats 1000000 in +/-- **The `(1, 1)_{-6}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the charged-lepton singlet**: its base-point + Taylor coefficients obey the Maurer–Cartan Leibniz law and intertwine the action + with the adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U)) + = -((x.antidiagonal.map fun p => + Complex.I * (-(6 : ℂ) * (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv + p.1 (maurerCartanForm U μ))).toU1Value) + * constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))).sum) := by + rw [Multiset.foldl_cons, jetPhase_pderiv, foldl_pderiv_neg, map_neg, + JetRing.constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by + rw [foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + ring)) + rw [repCoeff_eq, hMcons, neg_smul, ← sum_map_smul_id] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [gaugeAlgebraAction_apply, repCoeff_eq, smul_id_comp])) + · intro U x c + have hterm : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + gaugeAlgebraAction (IsGaugeField.adjointCoeff U p.1 c) + ∘ₗ IsGaugeField.repCoeff repJetGaugeGroupI U p.2 + = (Complex.I * (-(6 : ℂ) * constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) + (C c.toU1Value))) + * constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := fun p => by + rw [gaugeAlgebraAction_apply, repCoeff_eq, smul_id_comp, + IsGaugeField.adjointCoeff_toU1Value] + have hvan : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), p.1 ≠ 0 → + (Complex.I * (-(6 : ℂ) * constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) + (C c.toU1Value))) + * constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) = 0 := by + intro p hp + rw [JetRing.foldl_pderiv_C_of_ne_zero hp, map_zero, mul_zero, mul_zero, + zero_mul, zero_smul] + have hcollapse : (x.antidiagonal.map fun p => + (Complex.I * (-(6 : ℂ) * constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) + (C c.toU1Value))) + * constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)).sum + = (Complex.I * (-(6 : ℂ) * c.toU1Value) + * constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet) := by + rw [Multiset.sum_antidiagonal_eq_of_fst_ne_zero x + (fun p => (Complex.I * (-(6 : ℂ) * constantCoeff (p.1.foldl + (fun h ρ => pderiv ℂ ρ h) (C c.toU1Value))) + * constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U))) + • (LinearMap.id : LeptonSinglet →ₗ[ℂ] LeptonSinglet)) hvan, + show ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) + (C c.toU1Value : JetRing)) = C c.toU1Value from rfl, + constantCoeff_C] + rw [repCoeff_eq, gaugeAlgebraAction_apply, smul_id_comp, + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U)) + * (Complex.I * (-(6 : ℂ) * c.toU1Value)) + = Complex.I * (-(6 : ℂ) * c.toU1Value) + * constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (jetPhase U)) from + mul_comm _ _, + ← hcollapse] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => (hterm p).symm) + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/Basic.lean new file mode 100644 index 000000000..34a1fb80c --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/Basic.lean @@ -0,0 +1,66 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetComponentSpace +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +/-! +# The jet algebra of the charged-lepton singlet + +## i. Overview + +The jet algebra of the charged-lepton singlet is the exterior algebra on its jet +component space. It is the algebra in which the charged-lepton part of a +Lagrangian lives: the generators are the component functions `∂_s ψ_α` and their +conjugates, and the exterior product implements the anticommutativity of +fermionic fields. + +## ii. Key results + +- `JetAlgebra` : the exterior algebra on the jet component space. +- `JetAlgebra.ofGenerator` : the jet-algebra element of a generator. + +## iii. Table of contents + +- A. The jet algebra + - A.1. The generators of the jet algebra + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +open TensorProduct LagrangianTheory + +/-! + +## A. The jet algebra + +-/ + + +abbrev JetAlgebra : Type := ExteriorAlgebra ℂ JetComponentSpace + +namespace JetAlgebra + + +/-! + +### A.1. The generators of the jet algebra + +-/ + +noncomputable def ofGenerator (j : JetGenerators) : JetAlgebra := + ExteriorAlgebra.ι ℂ (JetComponentSpace.basis j) + +end JetAlgebra + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/GaugeAction.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/GaugeAction.lean new file mode 100644 index 000000000..6391dc853 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/GaugeAction.lean @@ -0,0 +1,234 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan +/-! +# The jet gauge action on the charged-lepton jet algebra + +## i. Overview + +The jet gauge group acts on the jet algebra of the charged-lepton singlet by the +exterior-algebra functor applied to its action on the jet component space. On a +derivative generator `∂_s ψ_α` the action is the all-orders Leibniz rule for the +contragredient hypercharge character `u ^ 6`: each splitting of the derivative +multi-index contributes a Taylor coefficient of the character against a lower +generator. + +## ii. Key results + +- `JetAlgebra.repJetGaugeGroupI` : the jet gauge action on the jet algebra. +- `JetAlgebra.repJetGaugeGroupI_ofGenerator_ψ` : the all-orders Leibniz rule. +- `JetAlgebra.repJetGaugeGroupIAlgHom` : the action as an algebra homomorphism. + +## iii. Table of contents + +- A. The action of the jet gauge group + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +namespace JetAlgebra + +open TensorProduct LagrangianTheory + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- The action of the (jet) gauge group on the jet algebra of the lepton singlets. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI JetAlgebra where + toFun g := (ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI g)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' g1 g2 := by + simp only [map_mul, Module.End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repJetGaugeGroupI_apply (g : JetGaugeGroupI) (x : JetAlgebra) : + repJetGaugeGroupI g x = + ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI g) x := rfl + +lemma repJetGaugeGroupI_apply_one (g : JetGaugeGroupI) : + repJetGaugeGroupI g (1 : JetAlgebra) = 1 := by + simp [repJetGaugeGroupI_apply] + +lemma repJetGaugeGroupI_apply_mul (g : JetGaugeGroupI) (x y : JetAlgebra) : + repJetGaugeGroupI g (x * y) = + repJetGaugeGroupI g x * repJetGaugeGroupI g y := by + simp [repJetGaugeGroupI_apply] + +/-- The value of the jet of gauge transformations at the base point acts by the + contragredient hypercharge scalar on the zeroth-order singlet generator, with + no derivative contributions. -/ +lemma repJetGaugeGroupI_ofGenerator_ψ_nil (g : JetGaugeGroupI) (α : Fin 2) : + repJetGaugeGroupI g (ofGenerator (.dψ {} α)) = g.eval.2.2 ^ 6 • ofGenerator (.dψ {} α) := by + rw [ofGenerator, repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι, + JetComponentSpace.basis_dψ_nil, Submonoid.smul_def] + simp only [JetComponentSpace.repJetGaugeGroupI, Representation.prod_apply_apply, + Representation.tprod_apply, dualJetAlgebraRepJetGaugeGroupI_apply, + Representation.trivial_apply, map_zero, TensorProduct.map_tmul, + DerivAlgebraComplex.jetRingAction_apply_one, map_pow, ← TensorProduct.smul_tmul', + SubmonoidClass.coe_pow, ← map_smul, Prod.smul_mk, smul_zero] + rfl + + +/-- The action of the gauge group on ∂_μ ψ takes it to + g • (∂_μ ψ + 6 i (maurerCartanU1Coeff g μ 0) • ψ)-/ +lemma repJetGaugeGroupI_ofGenerator_ψ_singleton (g : JetGaugeGroupI) + (μ : (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + repJetGaugeGroupI g (ofGenerator (.dψ {μ} α)) = + g.eval.2.2 ^ 6 • ofGenerator (.dψ {μ} α) - + ((6 : ℂ) * Complex.I * (maurerCartanU1Coeff g μ 0 : ℂ) * (g.eval.2.2 : ℂ) ^ 6) • + ofGenerator (.dψ {} α) := by + have hval : ((g.eval.2.2 : unitary ℂ) : ℂ) = + MvPowerSeries.constantCoeff ((g.2.2 : unitary JetRing) : JetRing) := rfl + have hcoeff : MvPowerSeries.coeff (Finsupp.single μ 1) + (((g.2.2 : unitary JetRing) : JetRing) ^ 6) = + -((6 : ℂ) * Complex.I * (maurerCartanU1Coeff g μ 0 : ℂ) * + MvPowerSeries.constantCoeff ((g.2.2 : unitary JetRing) : JetRing) ^ 6) := by + have h := congrArg (MvPowerSeries.coeff (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ)) + (pderiv_pow_unitary g μ 6) + rw [MvPowerSeries.coeff_pderiv] at h + simp only [MvPowerSeries.coeff_zero_eq_constantCoeff_apply, map_mul, map_pow, + MvPowerSeries.constantCoeff_C, Finsupp.coe_zero, Pi.zero_apply, Nat.cast_zero, + zero_add, mul_one] at h + rw [show ((maurerCartanU1Coeff g μ 0 : selfAdjoint ℂ) : ℂ) = + MvPowerSeries.constantCoeff (maurerCartanU1 g μ) from + MvPowerSeries.coeff_zero_eq_constantCoeff_apply _, h] + push_cast + ring + have hinl : ∀ x : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet, + (x, (0 : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet))) = + LinearMap.inl ℂ _ _ x := fun x => rfl + simp only [ofGenerator, repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι, + JetComponentSpace.basis_dψ_singleton, JetComponentSpace.basis_dψ_nil, + JetComponentSpace.repJetGaugeGroupI, Representation.prod_apply_apply, + Representation.tprod_apply, dualJetAlgebraRepJetGaugeGroupI_apply, + Representation.trivial_apply, map_zero, TensorProduct.map_tmul, + DerivAlgebraComplex.jetRingAction_apply_ι, hcoeff, TensorProduct.add_tmul, + ← TensorProduct.smul_tmul', Submonoid.smul_def, SubmonoidClass.coe_pow, + hval, map_pow, sub_eq_add_neg, neg_smul] + simp only [hinl, TensorProduct.neg_tmul, ← TensorProduct.smul_tmul', + map_add, map_neg, map_smul] + +/-- The jet gauge action on a general singlet generator: the all-orders Leibniz + rule. A jet of gauge transformations acts on the derivative generator + `∂_s ψ_α` through the Taylor coefficients of its contragredient hypercharge + power series `u ^ 6`: each splitting `s = p.1 + p.2` contributes the `p.1`-th + Taylor coefficient, with the divided-power multiplicity, times the lower + generator `∂_{p.2} ψ_α`. The zeroth- and first-order cases are + `repJetGaugeGroupI_ofGenerator_ψ_nil` and + `repJetGaugeGroupI_ofGenerator_ψ_singleton`. -/ +lemma repJetGaugeGroupI_ofGenerator_ψ (g : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + repJetGaugeGroupI g (ofGenerator (.dψ s α)) = + ∑ p ∈ Finset.antidiagonal (Multiset.toFinsupp s), + ((∏ μ, (Multiset.toFinsupp s μ).descFactorial (p.1 μ) : ℕ) : ℂ) • + MvPowerSeries.coeff p.1 (((g.2.2 : unitary JetRing) : JetRing) ^ 6) • + ofGenerator (.dψ (Finsupp.toMultiset p.2) α) := by + have hinl : ∀ x : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet, + (x, (0 : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet))) = + LinearMap.inl ℂ _ _ x := fun x => rfl + simp only [ofGenerator, repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι, + JetComponentSpace.basis_dψ, DerivAlgebraComplex.basis_apply, Finsupp.toMultiset_toFinsupp, + JetComponentSpace.repJetGaugeGroupI, Representation.prod_apply_apply, + Representation.tprod_apply, dualJetAlgebraRepJetGaugeGroupI_apply, + Representation.trivial_apply, map_zero, TensorProduct.map_tmul, + DerivAlgebraComplex.jetRingAction_basis] + simp only [hinl, TensorProduct.sum_tmul, ← TensorProduct.smul_tmul', map_sum, map_smul] + +noncomputable def repJetGaugeGroupIAlgHom (g : JetGaugeGroupI) : + AlgHom ℂ JetAlgebra JetAlgebra where + toFun := repJetGaugeGroupI g + map_one' := repJetGaugeGroupI_apply_one g + map_mul' := repJetGaugeGroupI_apply_mul g + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + commutes' := fun r => by simp [repJetGaugeGroupI_apply] + +/-! + +## B. Constant gauge transformations + +-/ + +/-- The action of constant gauge transformations on the charged-lepton jet algebra, obtained by +including a gauge transformation as a constant gauge jet. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI JetAlgebra := + repJetGaugeGroupI.comp JetGaugeGroupI.ofConstant + +/-- The constant gauge action is multiplicative. -/ +lemma repGaugeGroupI_apply_mul (g : GaugeGroupI) (x y : JetAlgebra) : + repGaugeGroupI g (x * y) = repGaugeGroupI g x * repGaugeGroupI g y := + repJetGaugeGroupI_apply_mul (JetGaugeGroupI.ofConstant g) x y + +/-- A constant gauge transformation acts on every ordinary lepton-jet generator through the +`U(1)` character determined by its hypercharge. -/ +lemma repGaugeGroupI_ofGenerator_ψ (g : GaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + repGaugeGroupI g (ofGenerator (.dψ s α)) = + (g.toU1 : ℂ) ^ 6 • ofGenerator (.dψ s α) := by + change repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) (ofGenerator (.dψ s α)) = + (g.toU1 : ℂ) ^ 6 • ofGenerator (.dψ s α) + rw [ofGenerator, repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι] + have hu : ((((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing)) : JetRing) = + MvPowerSeries.C (g.toU1 : ℂ) := rfl + simp only [JetComponentSpace.basis_dψ] + rw [JetComponentSpace.repJetGaugeGroupI_inl, hu, ← map_pow, + DerivAlgebraComplex.jetRingAction_C] + simp only [LinearMap.smul_apply, LinearMap.id_apply] + have hpair : + ((((g.toU1 : ℂ) ^ 6 • DerivAlgebraComplex.basis s) ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis α, 0) : JetComponentSpace) = + (g.toU1 : ℂ) ^ 6 • + ((DerivAlgebraComplex.basis s ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis α, 0) : JetComponentSpace) := by + simp only [TensorProduct.smul_tmul', Prod.smul_mk, smul_zero] + rw [hpair, map_smul] + +/-- A constant gauge transformation acts on every conjugate ordinary lepton-jet generator through +the conjugate `U(1)` character determined by its hypercharge. -/ +lemma repGaugeGroupI_ofGenerator_barψ (g : GaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + repGaugeGroupI g (ofGenerator (.dbarψ s α)) = + (star g.toU1 : ℂ) ^ 6 • ofGenerator (.dbarψ s α) := by + change repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) (ofGenerator (.dbarψ s α)) = + (star g.toU1 : ℂ) ^ 6 • ofGenerator (.dbarψ s α) + rw [ofGenerator, repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι] + have hu : ((((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing)) : JetRing) = + MvPowerSeries.C (g.toU1 : ℂ) := rfl + simp only [JetComponentSpace.basis_dbarψ] + rw [JetComponentSpace.repJetGaugeGroupI_inr, hu, JetRing.star_C, ← map_pow, + DerivAlgebraComplex.jetRingAction_C] + simp only [LinearMap.smul_apply, LinearMap.id_apply] + have hpair : + ((0, ((star g.toU1 : ℂ) ^ 6 • DerivAlgebraComplex.basis s) ⊗ₜ[ℂ] + LeptonSinglet.basis.conj.dualBasis α) : JetComponentSpace) = + (star g.toU1 : ℂ) ^ 6 • + ((0, DerivAlgebraComplex.basis s ⊗ₜ[ℂ] + LeptonSinglet.basis.conj.dualBasis α) : JetComponentSpace) := by + simp only [TensorProduct.smul_tmul', Prod.smul_mk, smul_zero] + rw [hpair, map_smul] + +end JetAlgebra + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/JetDeriv.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/JetDeriv.lean new file mode 100644 index 000000000..7ebcf2703 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/JetDeriv.lean @@ -0,0 +1,180 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.Basic +public import Mathlib.Algebra.TrivSqZeroExt.Basic +/-! +# The formal total derivative on the charged-lepton jet algebra + +## i. Overview + +The formal total spacetime derivative extends from the component functions to the +whole jet algebra as an even derivation. It is constructed by lifting the +generator map `ι x ↦ (ι x, ι (∂_μ x))` to an algebra homomorphism into the +trivial square-zero extension of the jet algebra. + +## ii. Key results + +- `JetAlgebra.jetDeriv` : the formal total spacetime derivative. +- `JetAlgebra.jetDeriv_ofGenerator` : the derivative of a generator. +- `JetAlgebra.jetDeriv_mul` : the Leibniz rule. +- `JetAlgebra.jetDeriv_comm` : total derivatives commute. + +## iii. Table of contents + +- A. The formal total derivative on the jet algebra +- B. Gauge transformations and total derivatives + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +namespace JetAlgebra + +/-! + +## A. The formal total derivative on the jet algebra + +The formal total spacetime derivative extends from the component functions to +the whole jet algebra as an even derivation: +`∂_μ (x y) = (∂_μ x) y + x (∂_μ y)`, with no Koszul signs. It is constructed by +lifting the generator map `ι x ↦ (ι x, ι (∂_μ x))` to an algebra homomorphism +into the trivial square-zero extension of the jet algebra; the square-zero +condition holds because degree-one elements of the exterior algebra +anticommute. + +-/ + +/-- The generator map of the total derivative into the trivial square-zero + extension of the jet algebra: `ι x ↦ (ι x, ι (∂_μ x))`. -/ +noncomputable def jetDerivGen (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace →ₗ[ℂ] TrivSqZeroExt JetAlgebra JetAlgebra where + toFun x := (ExteriorAlgebra.ι ℂ x, + ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x)) + map_add' x y := by + simp only [map_add] + rfl + map_smul' c x := by + simp only [map_smul, RingHom.id_apply] + rfl + +@[simp] +lemma jetDerivGen_fst (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + (jetDerivGen μ x).fst = ExteriorAlgebra.ι ℂ x := rfl + +@[simp] +lemma jetDerivGen_snd (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + (jetDerivGen μ x).snd = ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x) := rfl + +/-- The generator map squares to zero: degree-one elements of the exterior + algebra anticommute. -/ +lemma jetDerivGen_mul_self (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDerivGen μ x * jetDerivGen μ x = 0 := by + refine TrivSqZeroExt.ext ?_ ?_ + · rw [TrivSqZeroExt.fst_mul, jetDerivGen_fst, ExteriorAlgebra.ι_sq_zero, + TrivSqZeroExt.fst_zero] + · rw [TrivSqZeroExt.snd_mul, jetDerivGen_fst, jetDerivGen_snd, TrivSqZeroExt.snd_zero, + smul_eq_mul, op_smul_eq_mul] + exact ExteriorAlgebra.ι_add_mul_swap x (JetComponentSpace.jetDeriv μ x) + +/-- The lift of the total derivative to the trivial square-zero extension of the + jet algebra: the algebra homomorphism `x ↦ (x, ∂_μ x)`. -/ +noncomputable def jetDerivHom (μ : Fin 1 ⊕ Fin 3) : + JetAlgebra →ₐ[ℂ] TrivSqZeroExt JetAlgebra JetAlgebra := + ExteriorAlgebra.lift ℂ ⟨jetDerivGen μ, jetDerivGen_mul_self μ⟩ + +@[simp] +lemma jetDerivHom_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDerivHom μ (ExteriorAlgebra.ι ℂ x) = jetDerivGen μ x := by + rw [jetDerivHom, ExteriorAlgebra.lift_ι_apply] + +/-- The first component of the square-zero lift is the identity. -/ +@[simp] +lemma jetDerivHom_fst (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + (jetDerivHom μ x).fst = x := by + have h : (TrivSqZeroExt.fstHom ℂ JetAlgebra JetAlgebra).comp (jetDerivHom μ) = + AlgHom.id ℂ JetAlgebra := by + refine ExteriorAlgebra.hom_ext (LinearMap.ext fun v => ?_) + simp + exact DFunLike.congr_fun h x + +/-- The formal total spacetime derivative on the jet algebra of the + charged-lepton singlet in the direction `μ`: the even derivation extending the + shift `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the component functions. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℂ] JetAlgebra where + toFun x := (jetDerivHom μ x).snd + map_add' x y := congrArg TrivSqZeroExt.snd (map_add (jetDerivHom μ) x y) + map_smul' c x := congrArg TrivSqZeroExt.snd (map_smul (jetDerivHom μ) c x) + +lemma jetDeriv_apply (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + jetDeriv μ x = (jetDerivHom μ x).snd := rfl + +@[simp] +lemma jetDeriv_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace) : + jetDeriv μ (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x) := by + rw [jetDeriv_apply, jetDerivHom_ι, jetDerivGen_snd] + +/-- The total derivative appends the derivative index to each component + function. -/ +@[simp] +lemma jetDeriv_ofGenerator (μ : Fin 1 ⊕ Fin 3) (j : JetGenerators) : + jetDeriv μ (ofGenerator j) = ofGenerator (JetGenerators.shift μ j) := by + rw [ofGenerator, jetDeriv_ι, JetComponentSpace.jetDeriv_basis] + rfl + +@[simp] +lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv μ (1 : JetAlgebra) = 0 := + congrArg TrivSqZeroExt.snd (map_one (jetDerivHom μ)) + +/-- The total derivative is an even derivation: the Leibniz rule holds on the + jet algebra with no Koszul signs. -/ +lemma jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) (x y : JetAlgebra) : + jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y := by + have h : jetDeriv μ (x * y) = + (jetDerivHom μ x).fst * jetDeriv μ y + jetDeriv μ x * (jetDerivHom μ y).fst := + congrArg TrivSqZeroExt.snd (map_mul (jetDerivHom μ) x y) + rw [jetDerivHom_fst, jetDerivHom_fst] at h + exact h.trans (add_comm _ _) + +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => + simp [Algebra.algebraMap_eq_smul_one] + | ι v => + simp [JetComponentSpace.jetDeriv_comm] + | mul x y hx hy => + simp only [jetDeriv_mul, map_add, hx, hy] + abel + | add x y hx hy => + simp only [map_add, hx, hy] + +/-! + +## B. Gauge transformations and total derivatives + +Let ∂_s be the derivative with respect to the multi-index s. +On the action of the gauge group `∂_s (g • ψ) ≠ g • ∂_s ψ`. +The RHS of this properly takes account of derivatives of the gauge transformation, +while the LHS does not. + +What we want to show is that +`g • ∂_s ψ = ∑_{p + q = s} q ^ {|p|} • (∂_p g) • ∂_q ψ`. +where `q` is the charge of the field. + +-/ + +end JetAlgebra + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/LorentzAction.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/LorentzAction.lean new file mode 100644 index 000000000..0c762f470 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/LorentzAction.lean @@ -0,0 +1,162 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.JetDeriv +/-! +# The Lorentz action on the charged-lepton jet algebra + +## i. Overview + +The Lorentz group acts on the jet algebra of the charged-lepton singlet by the +exterior-algebra functor applied to its action on the jet component space. On a +generator the derivative symbols transform by the Lorentz matrix and the spinor +index contragrediently. + +## ii. Key results + +- `JetAlgebra.repLorentzGroup` : the Lorentz action on the jet algebra. +- `JetAlgebra.repLorentzGroup_ofGenerator` : the action on a generator. +- `JetAlgebra.repLorentzGroupAlgHom` : the action as an algebra homomorphism. + +## iii. Table of contents + +- A. The action of the Lorentz group + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +namespace JetAlgebra + +open Matrix MatrixGroups + +/-! + +## A. The action of the Lorentz group + +-/ + +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) JetAlgebra where + toFun g := (ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup g)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' g1 g2 := by + simp only [map_mul, Module.End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repLorentzGroup_apply (g : SL(2,ℂ)) (x : JetAlgebra) : + repLorentzGroup g x = + ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup g) x := rfl + +lemma repLorentzGroup_apply_one (g : SL(2,ℂ)) : + repLorentzGroup g 1 = 1 := by simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (g : SL(2,ℂ)) (x y : JetAlgebra) : + repLorentzGroup g (x * y) = repLorentzGroup g x * repLorentzGroup g y := by + simp [repLorentzGroup_apply] + +/-- The Lorentz action on a jet-algebra generator. -/ +lemma repLorentzGroup_ofGenerator (Λ : SL(2,ℂ)) (j : JetGenerators) : + repLorentzGroup Λ (ofGenerator j) = + ExteriorAlgebra.ι ℂ + (JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.basis j)) := by + rw [ofGenerator, repLorentzGroup_apply, ExteriorAlgebra.map_apply_ι] + +/-- The Lorentz action on the zeroth-order lepton generator. -/ +lemma repLorentzGroup_ofGenerator_ψ_nil (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup Λ (ofGenerator (.dψ {} α)) = + ∑ β, star ((Λ⁻¹).1 α β) • ofGenerator (.dψ {} β) := by + rw [repLorentzGroup_ofGenerator, + JetComponentSpace.repLorentzGroup_basis_dψ_nil, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, ofGenerator] + +/-- The Lorentz action on the first-order lepton generator. -/ +lemma repLorentzGroup_ofGenerator_ψ_singleton (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + repLorentzGroup Λ (ofGenerator (.dψ {μ} α)) = + ∑ ν, ∑ β, ((((Lorentz.SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * + star ((Λ⁻¹).1 α β)) • ofGenerator (.dψ {ν} β) := by + rw [repLorentzGroup_ofGenerator, + JetComponentSpace.repLorentzGroup_basis_dψ_singleton, map_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, ofGenerator] + +/-- The Lorentz action on the zeroth-order conjugate lepton generator. -/ +lemma repLorentzGroup_ofGenerator_barψ_nil (Λ : SL(2,ℂ)) (α : Fin 2) : + repLorentzGroup Λ (ofGenerator (.dbarψ {} α)) = + ∑ β, (Λ⁻¹).1 α β • ofGenerator (.dbarψ {} β) := by + rw [repLorentzGroup_ofGenerator, + JetComponentSpace.repLorentzGroup_basis_dbarψ_nil, map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, ofGenerator] + +/-- The Lorentz action on the first-order conjugate lepton generator. -/ +lemma repLorentzGroup_ofGenerator_barψ_singleton (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + repLorentzGroup Λ (ofGenerator (.dbarψ {μ} α)) = + ∑ ν, ∑ β, ((((Lorentz.SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * + (Λ⁻¹).1 α β) • ofGenerator (.dbarψ {ν} β) := by + rw [repLorentzGroup_ofGenerator, + JetComponentSpace.repLorentzGroup_basis_dbarψ_singleton, map_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_sum] + refine Finset.sum_congr rfl fun β _ => ?_ + rw [map_smul, ofGenerator] + + +noncomputable def repLorentzGroupAlgHom (Λ : SL(2,ℂ)) : + AlgHom ℂ JetAlgebra JetAlgebra where + toFun := repLorentzGroup Λ + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repLorentzGroup_apply_one Λ + map_mul' := repLorentzGroup_apply_mul Λ + commutes' r := by simp [repLorentzGroup_apply] + +set_option maxHeartbeats 4000000 in +/-- **The jet derivative on the charged-lepton jet algebra is a Lorentz vector.** -/ +lemma repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + repLorentzGroup Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup Λ x) := by + have hι : ∀ v : JetComponentSpace, repLorentzGroup Λ (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.repLorentzGroup Λ v) := fun v => by + rw [repLorentzGroup_apply, ExteriorAlgebra.map_apply_ι] + induction x using ExteriorAlgebra.induction with + | algebraMap r => + have h1 : jetDeriv μ (algebraMap ℂ JetAlgebra r) = 0 := by + rw [Algebra.algebraMap_eq_smul_one, map_smul, jetDeriv_one, smul_zero] + rw [h1, map_zero] + refine (Finset.sum_eq_zero fun a _ => ?_).symm + rw [Algebra.algebraMap_eq_smul_one, map_smul, repLorentzGroup_apply_one, map_smul, + jetDeriv_one, smul_zero, smul_zero] + | ι v => + rw [jetDeriv_ι, hι, hι, JetComponentSpace.repLorentzGroup_jetDeriv, map_sum] + exact Finset.sum_congr rfl fun a _ => by rw [map_smul, jetDeriv_ι] + | mul a b ha hb => + rw [jetDeriv_mul, map_add, repLorentzGroup_apply_mul, repLorentzGroup_apply_mul, ha, hb, + Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib, repLorentzGroup_apply_mul] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [jetDeriv_mul, smul_add, smul_mul_assoc, mul_smul_comm] + | add a b ha hb => + rw [map_add, map_add, map_add, ha, hb, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + +end JetAlgebra + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/MassDim.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/MassDim.lean new file mode 100644 index 000000000..216bc9819 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetAlgebra/MassDim.lean @@ -0,0 +1,544 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.JetAlgebra.JetDeriv +public import Physlib.Mathematics.PolynomialEval +/-! +# Mass dimension on the charged-lepton jet algebra + +## i. Overview + +*Note*: In this file we use the notion 'mass weight'. The idea being that the +'mass weight' is twice the mass dimension. This is because it is easier to work +exclusively with integers, and the mass dimension of the fermion fields is 3/2. + +The mass-weight polynomial records the mass weight of each homogeneous piece of +an element of the jet algebra in a formal variable. It gives the mass-weight +grading of the jet algebra, and its coefficientwise behaviour under the total +derivative shows that a derivative raises the mass weight by two. + +## ii. Key results + +- `JetAlgebra.massWeightPoly` : the mass-weight polynomial. +- `JetAlgebra.jetDeriv_massWeightPoly_coeff` : a derivative raises the mass weight by two. +- `JetAlgebra.massWeightSubmodule` : the submodule of elements of a given mass weight. +- `JetAlgebra.massWeightSubmodule_isInternal` : the mass-weight decomposition is direct. +- `JetAlgebra.massWeightScale` : the mass-dimension scaling. + +## iii. Table of contents + +- A. The mass-weight polynomial and the mass-weight grading +- B. The mass-weight scaling on the jet algebra + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +namespace JetAlgebra + +open Matrix MatrixGroups LagrangianTheory + +/-! + +## A. The mass-weight polynomial and the mass-weight grading + +-/ + + +/-- The mass-weight polynomial on the charged-lepton factor: the `ℂ`-algebra map + sending each generator `j` to `X ^ w * j`, where `w` is the mass weight of `j`. + It is `LeptonSinglet.JetAlgebra.massWeightScale` with the scalar `c` replaced by + the formal variable `X`. -/ +noncomputable def massWeightPoly : JetAlgebra →ₐ[ℂ] Polynomial JetAlgebra := + ExteriorAlgebra.lift ℂ + ⟨JetComponentSpace.basis.constr ℂ fun j => + Polynomial.monomial j.massWeight (ofGenerator j), by + set f := JetComponentSpace.basis.constr ℂ fun j => + Polynomial.monomial j.massWeight (ofGenerator j) with hf + set B := (LinearMap.mul ℂ (Polynomial JetAlgebra)).compl₁₂ f f with hBdef + have hB : B + B.flip = 0 := + LinearMap.ext_basis JetComponentSpace.basis JetComponentSpace.basis fun j k => by + simp only [hBdef, LinearMap.add_apply, LinearMap.compl₁₂_apply, LinearMap.flip_apply, + LinearMap.mul_apply', LinearMap.zero_apply, hf, Module.Basis.constr_basis, + ofGenerator, Polynomial.monomial_mul_monomial, + Nat.add_comm k.massWeight j.massWeight, ← map_add, + ExteriorAlgebra.ι_add_mul_swap, map_zero] + intro v + have h2 : (2 : ℂ) • (f v * f v) = 0 := by + rw [two_smul] + exact LinearMap.congr_fun (LinearMap.congr_fun hB v) v + simpa [smul_smul] using congrArg (fun y => (2⁻¹ : ℂ) • y) h2⟩ + +/-- Setting the formal variable to one recovers the original element. -/ +lemma massWeightPoly_eval_one (x : JetAlgebra) : + (massWeightPoly x).eval 1 = x := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℂ JetAlgebra) 1 + fun a => Commute.one_right a).comp massWeightPoly = AlgHom.id ℂ JetAlgebra := by + refine ExteriorAlgebra.hom_ext (Module.Basis.ext JetComponentSpace.basis fun j => ?_) + simp [massWeightPoly, ofGenerator] + exact AlgHom.congr_fun h x + +lemma eq_sum_massWeightPoly_coeff (x : JetAlgebra) : + x = ∑ n ∈ Polynomial.support (massWeightPoly x), (massWeightPoly x).coeff n := by + conv_lhs => rw [← massWeightPoly_eval_one x] + rw [Polynomial.eval_eq_sum, Polynomial.sum_def] + simp + +/-- Each generator is sent to `j * X ^ w`, where `w` is its mass weight. -/ +lemma massWeightPoly_ofGenerator (j : JetGenerators) : + massWeightPoly (ofGenerator j) = Polynomial.monomial j.massWeight (ofGenerator j) := by + rw [massWeightPoly, ofGenerator, ExteriorAlgebra.lift_ι_apply, Module.Basis.constr_basis] + rfl + +/-- `massWeightPoly` is injective, however, it is not surjective. -/ +lemma massWeightPoly_injective : Function.Injective massWeightPoly := by + intro x y h + rw [← massWeightPoly_eval_one x, ← massWeightPoly_eval_one y] + simp [h] + +/-- The total derivative of a linear generator: `massWeightPoly (∂_μ (ι v))` is + `X ^ 2` times a polynomial whose coefficients are the total derivatives of the + coefficients of `massWeightPoly (ι v)`. -/ +lemma exists_massWeightPoly_jetDeriv_ι (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace) : + ∃ q : Polynomial JetAlgebra, + massWeightPoly (jetDeriv μ (ExteriorAlgebra.ι ℂ v)) = Polynomial.X ^ 2 * q ∧ + ∀ n, q.coeff n = + jetDeriv μ ((massWeightPoly (ExteriorAlgebra.ι ℂ v)).coeff n) := by + have hv : v ∈ Submodule.span ℂ (Set.range JetComponentSpace.basis) := by + rw [JetComponentSpace.basis.span_eq] + trivial + induction hv using Submodule.span_induction with + | mem y hy => + obtain ⟨j, rfl⟩ := hy + refine ⟨Polynomial.monomial j.massWeight (ofGenerator (JetGenerators.shift μ j)), ?_, + fun n => ?_⟩ + · rw [show ExteriorAlgebra.ι ℂ (JetComponentSpace.basis j) = ofGenerator j from rfl, + jetDeriv_ofGenerator, massWeightPoly_ofGenerator, JetGenerators.massWeight_shift, + Polynomial.X_pow_eq_monomial, Polynomial.monomial_mul_monomial, one_mul, + Nat.add_comm 2 j.massWeight] + · rw [show ExteriorAlgebra.ι ℂ (JetComponentSpace.basis j) = ofGenerator j from rfl, + massWeightPoly_ofGenerator, Polynomial.coeff_monomial, Polynomial.coeff_monomial] + split_ifs with h + · rw [jetDeriv_ofGenerator] + · rw [map_zero] + | zero => exact ⟨0, by simp, fun n => by simp⟩ + | add y z _ _ hy hz => + obtain ⟨qy, hqy, cy⟩ := hy + obtain ⟨qz, hqz, cz⟩ := hz + refine ⟨qy + qz, ?_, fun n => ?_⟩ + · simp only [map_add, hqy, hqz, mul_add] + · simp only [map_add, Polynomial.coeff_add, cy, cz] + | smul c y _ hy => + obtain ⟨qy, hqy, cy⟩ := hy + refine ⟨c • qy, ?_, fun n => ?_⟩ + · simp only [map_smul, hqy, mul_smul_comm] + · simp only [map_smul, Polynomial.coeff_smul, cy] + +/-- Rearrangement used for the Leibniz step: `X ^ 2` is central, so it can be + pulled out of a Leibniz combination. -/ +private lemma X_sq_mul_leibniz {R : Type} [Semiring R] (p q r s : Polynomial R) : + Polynomial.X ^ 2 * p * q + r * (Polynomial.X ^ 2 * s) = + Polynomial.X ^ 2 * (p * q + r * s) := by + rw [mul_add, mul_assoc, ← mul_assoc r, ← Polynomial.X_pow_mul, mul_assoc] + +/-- The polynomial half of the Leibniz step: the mass-weight polynomial of + `∂_μ (a * b)` is `X ^ 2` times the Leibniz combination. -/ +lemma massWeightPoly_jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) {a b : JetAlgebra} + {qa qb : Polynomial JetAlgebra} + (hqa : massWeightPoly (jetDeriv μ a) = Polynomial.X ^ 2 * qa) + (hqb : massWeightPoly (jetDeriv μ b) = Polynomial.X ^ 2 * qb) : + massWeightPoly (jetDeriv μ (a * b)) = + Polynomial.X ^ 2 * (qa * massWeightPoly b + massWeightPoly a * qb) := by + rw [jetDeriv_mul, map_add massWeightPoly, map_mul massWeightPoly, map_mul massWeightPoly, + hqa, hqb, X_sq_mul_leibniz] + +/-- The coefficient half of the Leibniz step: the coefficients of the Leibniz + combination are the total derivatives of the coefficients of `a * b`. -/ +lemma coeff_mul_jetDeriv (μ : Fin 1 ⊕ Fin 3) {a b : JetAlgebra} + {qa qb : Polynomial JetAlgebra} + (ca : ∀ n, qa.coeff n = jetDeriv μ ((massWeightPoly a).coeff n)) + (cb : ∀ n, qb.coeff n = jetDeriv μ ((massWeightPoly b).coeff n)) (n : ℕ) : + (qa * massWeightPoly b + massWeightPoly a * qb).coeff n = + jetDeriv μ ((massWeightPoly (a * b)).coeff n) := by + rw [Polynomial.coeff_add, Polynomial.coeff_mul, Polynomial.coeff_mul, + ← Finset.sum_add_distrib, map_mul massWeightPoly, Polynomial.coeff_mul, + map_sum (jetDeriv μ)] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [jetDeriv_mul, ca, cb] + +/-- The Leibniz rule propagates the shift: if the mass-weight polynomials of the + total derivatives of `a` and `b` are `X ^ 2` times the coefficientwise total + derivatives, then so is that of `a * b`. -/ +lemma exists_massWeightPoly_jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) {a b : JetAlgebra} + {qa qb : Polynomial JetAlgebra} + (hqa : massWeightPoly (jetDeriv μ a) = Polynomial.X ^ 2 * qa) + (ca : ∀ n, qa.coeff n = jetDeriv μ ((massWeightPoly a).coeff n)) + (hqb : massWeightPoly (jetDeriv μ b) = Polynomial.X ^ 2 * qb) + (cb : ∀ n, qb.coeff n = jetDeriv μ ((massWeightPoly b).coeff n)) : + ∃ q : Polynomial JetAlgebra, massWeightPoly (jetDeriv μ (a * b)) = Polynomial.X ^ 2 * q ∧ + ∀ n, q.coeff n = jetDeriv μ ((massWeightPoly (a * b)).coeff n) := + ⟨qa * massWeightPoly b + massWeightPoly a * qb, + massWeightPoly_jetDeriv_mul μ hqa hqb, coeff_mul_jetDeriv μ ca cb⟩ + +/-- The mass-weight polynomial of a total derivative is `X ^ 2` times a polynomial + whose coefficients are the total derivatives of the coefficients: the total + derivative raises the mass weight by two. -/ +lemma exists_massWeightPoly_jetDeriv (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + ∃ q : Polynomial JetAlgebra, massWeightPoly (jetDeriv μ x) = Polynomial.X ^ 2 * q ∧ + ∀ n, q.coeff n = jetDeriv μ ((massWeightPoly x).coeff n) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => + have hr : jetDeriv μ (algebraMap ℂ JetAlgebra r) = 0 := by + rw [Algebra.algebraMap_eq_smul_one, map_smul (jetDeriv μ), jetDeriv_one, smul_zero] + refine ⟨0, ?_, fun n => ?_⟩ + · rw [hr, map_zero massWeightPoly, mul_zero] + · rw [Polynomial.coeff_zero, AlgHom.commutes, Polynomial.algebraMap_apply, + Polynomial.coeff_C] + split_ifs with h + · rw [hr] + · rw [map_zero (jetDeriv μ)] + | ι v => exact exists_massWeightPoly_jetDeriv_ι μ v + | mul a b ha hb => + obtain ⟨qa, hqa, ca⟩ := ha + obtain ⟨qb, hqb, cb⟩ := hb + exact exists_massWeightPoly_jetDeriv_mul μ hqa ca hqb cb + | add a b ha hb => + obtain ⟨qa, hqa, ca⟩ := ha + obtain ⟨qb, hqb, cb⟩ := hb + refine ⟨qa + qb, ?_, fun n => ?_⟩ + · simp only [map_add, hqa, hqb, mul_add] + · simp only [map_add, Polynomial.coeff_add, ca, cb] + +/-- The total derivative raises the mass weight by two: it takes the part of `x` of + mass weight `n` to the part of `∂_μ x` of mass weight `n + 2`. -/ +lemma jetDeriv_massWeightPoly_coeff (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) (n : ℕ) : + jetDeriv μ ((massWeightPoly x).coeff n) = (massWeightPoly (jetDeriv μ x)).coeff (n + 2) := by + obtain ⟨q, hq, hc⟩ := exists_massWeightPoly_jetDeriv μ x + rw [hq, Polynomial.coeff_X_pow_mul, hc] + + +/-- The coefficients of the mass-weight polynomial of a linear generator are + homogeneous: each basis vector is homogeneous, and a general vector is a + combination of basis vectors. -/ +lemma massWeightPoly_coeff_massWeightPoly_ι (n : ℕ) (v : JetComponentSpace) : + massWeightPoly ((massWeightPoly (ExteriorAlgebra.ι ℂ v)).coeff n) = + Polynomial.monomial n ((massWeightPoly (ExteriorAlgebra.ι ℂ v)).coeff n) := by + have hv : v ∈ Submodule.span ℂ (Set.range JetComponentSpace.basis) := by + rw [JetComponentSpace.basis.span_eq] + trivial + induction hv using Submodule.span_induction generalizing n with + | mem y hy => + obtain ⟨j, rfl⟩ := hy + rw [show ExteriorAlgebra.ι ℂ (JetComponentSpace.basis j) = ofGenerator j from rfl, + massWeightPoly_ofGenerator, Polynomial.coeff_monomial] + split_ifs with h + · rw [← h, massWeightPoly_ofGenerator] + · simp only [map_zero] + | zero => simp only [map_zero, Polynomial.coeff_zero] + | add y z _ _ hy hz => + simp only [map_add, Polynomial.coeff_add] + rw [hy n, hz n] + | smul c y _ hy => + simp only [map_smul, Polynomial.coeff_smul] + rw [hy n, Polynomial.smul_monomial] + +/-- Homogeneity of the coefficients is inherited by products: the `n`-th coefficient + of a product is a sum of products of coefficients of complementary degrees. -/ +lemma massWeightPoly_coeff_massWeightPoly_mul {a b : JetAlgebra} + (ha : ∀ n, massWeightPoly ((massWeightPoly a).coeff n) = + Polynomial.monomial n ((massWeightPoly a).coeff n)) + (hb : ∀ n, massWeightPoly ((massWeightPoly b).coeff n) = + Polynomial.monomial n ((massWeightPoly b).coeff n)) (n : ℕ) : + massWeightPoly ((massWeightPoly (a * b)).coeff n) = + Polynomial.monomial n ((massWeightPoly (a * b)).coeff n) := by + rw [map_mul massWeightPoly a b, Polynomial.coeff_mul, map_sum massWeightPoly, + map_sum (Polynomial.monomial n)] + refine Finset.sum_congr rfl fun p hp => ?_ + rw [Finset.mem_antidiagonal] at hp + subst hp + rw [map_mul massWeightPoly, ha p.1, hb p.2, Polynomial.monomial_mul_monomial] + +/-- The coefficients of a mass-weight polynomial are homogeneous: the coefficient of + `X ^ n` in `massWeightPoly x` is sent by `massWeightPoly` to `X ^ n` times itself. + + This fails for a general `p : Polynomial JetAlgebra` in place of `massWeightPoly x`: + for `p = Polynomial.monomial 5 1` it would say `1 = X ^ 5`. -/ +lemma massWeightPoly_coeff_massWeightPoly (n : ℕ) (x : JetAlgebra) : + massWeightPoly ((massWeightPoly x).coeff n) = + Polynomial.monomial n ((massWeightPoly x).coeff n) := by + induction x using ExteriorAlgebra.induction generalizing n with + | algebraMap r => + rw [AlgHom.commutes, Polynomial.algebraMap_apply, Polynomial.coeff_C] + split_ifs with h + · subst h + rw [AlgHom.commutes, Polynomial.algebraMap_apply, Polynomial.monomial_zero_left] + · simp only [map_zero] + | ι v => exact massWeightPoly_coeff_massWeightPoly_ι n v + | mul a b ha hb => exact massWeightPoly_coeff_massWeightPoly_mul ha hb n + | add a b ha hb => + rw [map_add massWeightPoly a b, Polynomial.coeff_add, map_add massWeightPoly, ha n, hb n] + exact (map_add (Polynomial.monomial n) _ _).symm + + +/-- The submodule of elements of mass weight `n`: those `x` whose mass-weight + polynomial is `x * X ^ n`. -/ +def massWeightSubmodule (n : ℕ) : Submodule ℂ JetAlgebra where + carrier := {x | massWeightPoly x = Polynomial.monomial n x} + add_mem' {a b} ha hb := by + simp only [Set.mem_setOf_eq, map_add] at ha hb ⊢ + rw [ha, hb] + zero_mem' := by simp + smul_mem' c x hx := by + simp only [Set.mem_setOf_eq, map_smul] at hx ⊢ + rw [hx, Polynomial.smul_monomial] + +@[simp] +lemma mem_massWeightSubmodule {n : ℕ} {x : JetAlgebra} : + x ∈ massWeightSubmodule n ↔ massWeightPoly x = Polynomial.monomial n x := Iff.rfl + +/-- The generator `j` has mass weight `j.massWeight`. -/ +lemma ofGenerator_mem_massWeightSubmodule (j : JetGenerators) : + ofGenerator j ∈ massWeightSubmodule j.massWeight := + massWeightPoly_ofGenerator j + +/-- Mass weights add under multiplication, and `1` has mass weight zero. -/ +instance : SetLike.GradedMonoid massWeightSubmodule where + one_mem := by simp + mul_mem {m n x y} hx hy := by + simp only [mem_massWeightSubmodule, map_mul] at hx hy ⊢ + rw [hx, hy, Polynomial.monomial_mul_monomial] + +/-- The coefficient of `X ^ n` in the mass-weight polynomial of `x` has mass + weight `n`. -/ +lemma coeff_massWeightPoly_mem_massWeightSubmodule (n : ℕ) (x : JetAlgebra) : + (massWeightPoly x).coeff n ∈ massWeightSubmodule n := + massWeightPoly_coeff_massWeightPoly n x + +/-- On an element of mass weight `n`, the `n`-th coefficient of the mass-weight + polynomial is the element itself. -/ +lemma coeff_massWeightPoly_of_mem {n : ℕ} {x : JetAlgebra} + (hx : x ∈ massWeightSubmodule n) : (massWeightPoly x).coeff n = x := by + rw [mem_massWeightSubmodule.mp hx, Polynomial.coeff_monomial, if_pos rfl] + +/-- On an element of mass weight `m`, every other coefficient of the mass-weight + polynomial vanishes. -/ +lemma coeff_massWeightPoly_of_mem_ne {m n : ℕ} {x : JetAlgebra} (hmn : m ≠ n) + (hx : x ∈ massWeightSubmodule m) : (massWeightPoly x).coeff n = 0 := by + rw [mem_massWeightSubmodule.mp hx, Polynomial.coeff_monomial, if_neg hmn] + +/-- The `i`-th coefficient of the mass-weight polynomial vanishes on the span of + all the *other* weight submodules. This is the separation property that makes + the weight decomposition direct. -/ +lemma coeff_massWeightPoly_eq_zero_of_mem_iSup_ne (i : ℕ) {x : JetAlgebra} + (hx : x ∈ ⨆ (j : ℕ) (_ : j ≠ i), massWeightSubmodule j) : + (massWeightPoly x).coeff i = 0 := by + induction hx using Submodule.iSup_induction' with + | mem j x hj => + by_cases hne : j ≠ i + · rw [iSup_pos hne] at hj + exact coeff_massWeightPoly_of_mem_ne hne hj + · rw [iSup_neg hne, Submodule.mem_bot] at hj + rw [hj, map_zero, Polynomial.coeff_zero] + | zero => simp + | add a b _ _ ha hb => rw [map_add, Polynomial.coeff_add, ha, hb, add_zero] + +/-- The weight submodules span the whole jet algebra. -/ +lemma iSup_massWeightSubmodule_eq_top : + ⨆ n : ℕ, massWeightSubmodule n = ⊤ := by + rw [eq_top_iff] + intro x _ + rw [eq_sum_massWeightPoly_coeff x] + exact Submodule.sum_mem _ fun n _ => Submodule.mem_iSup_of_mem n + (coeff_massWeightPoly_mem_massWeightSubmodule n x) + +/-- The weight submodules are independent: an element of weight `i` lying in the + span of the other weights is zero, since taking the `i`-th coefficient of the + mass-weight polynomial returns it on the one and kills it on the other. -/ +lemma iSupIndep_massWeightSubmodule : iSupIndep massWeightSubmodule := by + intro i + rw [Submodule.disjoint_def] + intro x hx hx' + rw [← coeff_massWeightPoly_of_mem hx] + exact coeff_massWeightPoly_eq_zero_of_mem_iSup_ne i hx' + +/-- The jet algebra is the internal direct sum of its mass-weight submodules. -/ +lemma massWeightSubmodule_isInternal : DirectSum.IsInternal massWeightSubmodule := + (DirectSum.isInternal_submodule_iff_iSupIndep_and_iSup_eq_top _).mpr + ⟨iSupIndep_massWeightSubmodule, iSup_massWeightSubmodule_eq_top⟩ + +noncomputable instance : GradedAlgebra massWeightSubmodule := + DirectSum.IsInternal.gradedAlgebra massWeightSubmodule_isInternal + + +/-! + +## B. The mass-weight scaling on the jet algebra + +-/ + +/-- The mass-dimension scaling on the jet algebra of the charged-lepton singlet: + the (linear map underlying the) algebra map multiplying each generator by + `c ^ w`, where `w` is twice its mass dimension. -/ +noncomputable def massWeightScale (c : ℂ) : JetAlgebra →ₐ[ℂ] JetAlgebra := + (ExteriorAlgebra.map (JetComponentSpace.massWeightScale c)) + +lemma massWeightScale_apply (c : ℂ) (x : JetAlgebra) : + massWeightScale c x = + ExteriorAlgebra.map (JetComponentSpace.massWeightScale c) x := rfl + +/-- Each generator scales by `c` to the power of its mass weight. -/ +@[simp] +lemma massWeightScale_ofGenerator (c : ℂ) (j : JetGenerators) : + massWeightScale c (ofGenerator j) = c ^ j.massWeight • ofGenerator j := by + rw [ofGenerator, massWeightScale_apply, ExteriorAlgebra.map_apply_ι, + JetComponentSpace.massWeightScale_basis, map_smul] + +@[simp] +lemma massWeightScale_ι (c : ℂ) (v : JetComponentSpace) : + massWeightScale c (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.massWeightScale c v) := by + rw [massWeightScale_apply, ExteriorAlgebra.map_apply_ι] + + +/-- The total derivative raises the mass weight by two: the scaling and the + derivative commute up to `c ^ 2`. -/ +lemma massWeightScale_jetDeriv (c : ℂ) (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + massWeightScale c (jetDeriv μ x) = c ^ 2 • jetDeriv μ (massWeightScale c x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => + simp [Algebra.algebraMap_eq_smul_one] + | ι v => + rw [jetDeriv_ι, massWeightScale_ι, JetComponentSpace.massWeightScale_jetDeriv, + map_smul, massWeightScale_ι, jetDeriv_ι] + | mul x y hx hy => + simp [map_mul, jetDeriv_mul, hx, hy, smul_add] + | add x y hx hy => + simp only [map_add, hx, hy, smul_add] + +/-- The mass-dimension scaling commutes with the gauge action of jets of + constant gauge transformations. This fails for a general jet: the gauge action + sends `∂ψ` to `u(0)⁶ ∂ψ + (∂u⁶)(0) ψ + …`, mixing derivative degrees + downwards, while the scaling weights each degree differently, so the two + compositions already differ on first-derivative generators. -/ +lemma massWeightScale_repJetGaugeGroupI_ofConstant (c : ℂ) (g : GaugeGroupI) : + massWeightScale c ∘ₗ JetAlgebra.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + JetAlgebra.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) ∘ₗ massWeightScale c := by + have h : (massWeightScale c).comp + (ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI + (JetGaugeGroupI.ofConstant g))) = + (ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI + (JetGaugeGroupI.ofConstant g))).comp (massWeightScale c) := by + rw [massWeightScale, ExteriorAlgebra.map_comp_map, ExteriorAlgebra.map_comp_map, + JetComponentSpace.massWeightScale_repJetGaugeGroupI_ofConstant] + have h2 := congrArg AlgHom.toLinearMap h + rw [AlgHom.comp_toLinearMap, AlgHom.comp_toLinearMap] at h2 + exact h2 + +lemma massWeightScale_repLorentzGroup (c : ℂ) (g : SL(2,ℂ)) : + massWeightScale c ∘ₗ JetAlgebra.repLorentzGroup g = + JetAlgebra.repLorentzGroup g ∘ₗ massWeightScale c := by + have h : (massWeightScale c).comp + (ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup g)) = + (ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup g)).comp + (massWeightScale c) := by + rw [massWeightScale, ExteriorAlgebra.map_comp_map, ExteriorAlgebra.map_comp_map, + JetComponentSpace.massWeightScale_repLorentzGroup] + have h2 := congrArg AlgHom.toLinearMap h + rw [AlgHom.comp_toLinearMap, AlgHom.comp_toLinearMap] at h2 + exact h2 + +lemma massWeightScale_repJetGaugeGroupI_ofConstant_apply (c : ℂ) (g : GaugeGroupI) + (x : JetAlgebra) : + massWeightScale c + (JetAlgebra.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) x) = + JetAlgebra.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) + (massWeightScale c x) := + DFunLike.congr_fun (massWeightScale_repJetGaugeGroupI_ofConstant c g) x + +lemma massWeightScale_repLorentzGroup_apply (c : ℂ) (g : SL(2,ℂ)) (x : JetAlgebra) : + massWeightScale c (JetAlgebra.repLorentzGroup g x) = + JetAlgebra.repLorentzGroup g (massWeightScale c x) := by + have h := massWeightScale_repLorentzGroup c g + exact DFunLike.congr_fun h x + +/-! + +## C. Evaluating the mass-weight polynomial + +The mass-weight polynomial and the mass-weight scaling are two descriptions of the same +grading: evaluating the polynomial at a scalar gives the scaling by that scalar. Since a +polynomial with coefficients in an algebra over an infinite field is determined by its +values at the scalars, statements proved for one description transfer to the other. + +-/ + +/-- Evaluating the mass-weight polynomial at a scalar is the mass-weight scaling by that + scalar. Both send a generator of weight `w` to `c ^ w` times itself, and both are + algebra maps. -/ +lemma eval_massWeightPoly (c : ℂ) (x : JetAlgebra) : + (massWeightPoly x).eval (algebraMap ℂ JetAlgebra c) = massWeightScale c x := by + have h : (Polynomial.eval₂AlgHom (AlgHom.id ℂ JetAlgebra) + (algebraMap ℂ JetAlgebra c) + (fun a => (Algebra.commutes c a).symm)).comp massWeightPoly = + (massWeightScale c : JetAlgebra →ₐ[ℂ] JetAlgebra) := by + refine ExteriorAlgebra.hom_ext (Module.Basis.ext JetComponentSpace.basis fun j => ?_) + show (massWeightPoly (ofGenerator j)).eval (algebraMap ℂ JetAlgebra c) = + massWeightScale c (ofGenerator j) + rw [massWeightPoly_ofGenerator, massWeightScale_ofGenerator, Polynomial.eval_monomial, + ← map_pow, ← Algebra.commutes, ← Algebra.smul_def] + exact AlgHom.congr_fun h x + +/-! + +## D. The mass weight of derivatives and of transformed elements + +-/ + +/-- The total derivative raises the mass weight by two: its mass-weight polynomial is + `X ^ 2` times the coefficientwise total derivative. -/ +lemma massWeightPoly_jetDeriv (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + massWeightPoly (jetDeriv μ x) = + Polynomial.X ^ 2 * Polynomial.mapCoeffs (jetDeriv μ) (massWeightPoly x) := by + obtain ⟨q, hq, hc⟩ := exists_massWeightPoly_jetDeriv μ x + rw [hq] + congr 1 + refine Polynomial.ext fun n => ?_ + rw [Polynomial.coeff_mapCoeffs (map_zero (jetDeriv μ)), hc] + +/-- The Lorentz action preserves mass weights: the mass-weight polynomial of a transformed + element is the transform of its mass-weight polynomial. -/ +lemma massWeightPoly_repLorentzGroup (Λ : SL(2,ℂ)) (x : JetAlgebra) : + massWeightPoly (repLorentzGroup Λ x) = + Polynomial.mapAlgHom (repLorentzGroupAlgHom Λ) (massWeightPoly x) := by + refine Polynomial.ext_of_forall_eval_algebraMap (k := ℂ) fun c => ?_ + rw [eval_massWeightPoly, Polynomial.eval_algebraMap_mapAlgHom, eval_massWeightPoly, + massWeightScale_repLorentzGroup_apply] + rfl + +/-- Jets of constant gauge transformations preserve mass weights. This fails for a general + jet: the higher Taylor coefficients of the hypercharge character lower the derivative + degree, mixing weights. -/ +lemma massWeightPoly_repJetGaugeGroupI_ofConstant (g : GaugeGroupI) (x : JetAlgebra) : + massWeightPoly (repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) x) = + Polynomial.mapAlgHom (repJetGaugeGroupIAlgHom (JetGaugeGroupI.ofConstant g)) + (massWeightPoly x) := by + refine Polynomial.ext_of_forall_eval_algebraMap (k := ℂ) fun c => ?_ + rw [eval_massWeightPoly, Polynomial.eval_algebraMap_mapAlgHom, eval_massWeightPoly, + massWeightScale_repJetGaugeGroupI_ofConstant_apply] + rfl + +end JetAlgebra + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetComponentSpace.lean b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetComponentSpace.lean new file mode 100644 index 000000000..3320ac8b0 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/LeptonSinglet/JetComponentSpace.lean @@ -0,0 +1,916 @@ +/- +Copyright (c) 2026 Nathaneal Sajan. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Nathaneal Sajan +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.LagrangianTheory.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +/-! +# The jet component space of the charged-lepton singlet + +## i. Overview + +A Lagrangian containing a charged-lepton singlet may have terms of the form +`∂_μ ∂_ν ψ`. These expressions are component functions taking a section of the +bundle of charged-lepton singlets and returning a complex number. The space of +all such component functions is the jet component space of the charged-lepton +singlet. + +The jet gauge group and the Lorentz group act on this space, and it carries the +formal total spacetime derivative and the mass-weight scaling. + +## ii. Key results + +- `JetGenerators` : the generators `∂_s ψ_α` and `∂_s ψ̄_α` of the component space. +- `JetComponentSpace` : the space of component functions. +- `JetComponentSpace.repLorentzGroup` : the Lorentz action. +- `JetComponentSpace.repJetGaugeGroupI` : the jet gauge action. +- `JetComponentSpace.jetDeriv` : the formal total spacetime derivative. +- `JetComponentSpace.massWeightScale` : the mass-weight scaling. + +## iii. Table of contents + +- A. The jet component vector space + - A.1. The action of the jet gauge group +- B. The formal total derivative on the component functions +- C. The mass-weight scaling on the component functions +- D. The total derivative on the summands of the component space + +-/ + +@[expose] public section + +namespace StandardModel + +namespace LeptonSinglet + +open Matrix MatrixGroups + +/-! + +## A. The jet component vector space + +A Lagrangian containing a charged lepton singlet may have terms +of the form `∂_μ ∂_ν ψ`. These expressions should be considered as +component functions which takes in a section of the +bundle of charged lepton singlets and returns a complex number. + +The space of all such component functions is what we call the jet component space. +The lagrangian is an element of the algebra over all such component +functions for all the fields in the theory. + +For matter particles, the (jet) Gauge group acts on the +jet component space as a representation. This is not case for the gauge bosons. + +-/ + +open TensorProduct LagrangianTheory + +inductive JetGenerators where + | dψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : JetGenerators + | dbarψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : JetGenerators +deriving DecidableEq + +def JetGenerators.equiv : JetGenerators ≃ + (Multiset (Fin 1 ⊕ Fin 3) × Fin 2 ⊕ Multiset (Fin 1 ⊕ Fin 3) × Fin 2) where + toFun + | JetGenerators.dψ s α => Sum.inl (s, α) + | JetGenerators.dbarψ s α => Sum.inr (s, α) + invFun + | Sum.inl (s, α) => JetGenerators.dψ s α + | Sum.inr (s, α) => JetGenerators.dbarψ s α + left_inv := by + intro x + cases x <;> rfl + right_inv := by + intro x + cases x <;> rfl + +def JetGenerators.massWeight : JetGenerators → ℕ + | JetGenerators.dψ s _ => 3 + 2 * s.card + | JetGenerators.dbarψ s _ => 3 + 2 * s.card + +abbrev JetComponentSpace := + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet) × + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet)) + +noncomputable def JetComponentSpace.basis : Module.Basis JetGenerators ℂ JetComponentSpace := + ((DerivAlgebraComplex.basis.tensorProduct + LeptonSinglet.basis.dualBasis).prod + (DerivAlgebraComplex.basis.tensorProduct + (LeptonSinglet.basis.conj.dualBasis))).reindex JetGenerators.equiv.symm + +/-- The basis vector of the jet component space at the zeroth-order singlet + generator: the unit of the dual jet algebra tensored with the dual basis of the + singlet, in the first (unconjugated) factor. -/ +lemma JetComponentSpace.basis_dψ_nil (α : Fin 2) : + JetComponentSpace.basis (.dψ {} α) = + ((1 : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis α, 0) := by + rw [JetComponentSpace.basis, Module.Basis.reindex_apply, + show JetGenerators.equiv.symm.symm (.dψ {} α) = Sum.inl ({}, α) from rfl] + refine Prod.ext ?_ ?_ + · rw [Module.Basis.prod_apply_inl_fst, Module.Basis.tensorProduct_apply', + DerivAlgebraComplex.basis_nil] + · rw [Module.Basis.prod_apply_inl_snd] + +/-- The basis vector of the jet component space at a first-order singlet + generator: the dual derivative symbol tensored with the dual basis of the + singlet, in the first (unconjugated) factor. -/ +lemma JetComponentSpace.basis_dψ_singleton (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + JetComponentSpace.basis (.dψ {μ} α) = + (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis α, 0) := by + rw [JetComponentSpace.basis, Module.Basis.reindex_apply, + show JetGenerators.equiv.symm.symm (.dψ {μ} α) = Sum.inl ({μ}, α) from rfl] + refine Prod.ext ?_ ?_ + · rw [Module.Basis.prod_apply_inl_fst, Module.Basis.tensorProduct_apply', + DerivAlgebraComplex.basis_singleton] + · rw [Module.Basis.prod_apply_inl_snd] + +/-- The basis vector of the jet component space at a general singlet generator: + the dual jet algebra basis vector at its multiset of derivative indices, + tensored with the dual basis of the singlet, in the first (unconjugated) + factor. -/ +lemma JetComponentSpace.basis_dψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + JetComponentSpace.basis (.dψ s α) = + (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] LeptonSinglet.basis.dualBasis α, 0) := by + rw [JetComponentSpace.basis, Module.Basis.reindex_apply, + show JetGenerators.equiv.symm.symm (.dψ s α) = Sum.inl (s, α) from rfl] + refine Prod.ext ?_ ?_ + · rw [Module.Basis.prod_apply_inl_fst, Module.Basis.tensorProduct_apply'] + · rw [Module.Basis.prod_apply_inl_snd] + +/-- The basis vector of the jet component space at a general conjugate-singlet + generator: the dual jet algebra basis vector at its multiset of derivative + indices, tensored with the conjugate dual basis of the singlet, in the second + (conjugated) factor. -/ +lemma JetComponentSpace.basis_dbarψ (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + JetComponentSpace.basis (.dbarψ s α) = + (0, DerivAlgebraComplex.basis s ⊗ₜ[ℂ] LeptonSinglet.basis.conj.dualBasis α) := by + rw [JetComponentSpace.basis, Module.Basis.reindex_apply, + show JetGenerators.equiv.symm.symm (.dbarψ s α) = Sum.inr (s, α) from rfl] + refine Prod.ext ?_ ?_ + · rw [Module.Basis.prod_apply_inr_fst] + · rw [Module.Basis.prod_apply_inr_snd, Module.Basis.tensorProduct_apply'] + +noncomputable def JetComponentSpace.repLorentzGroup : + Representation ℂ (SL(2,ℂ)) JetComponentSpace := + (DerivAlgebraComplex.repLorentzGroup.tprod LeptonSinglet.repLorentzGroup.dual).prod + (DerivAlgebraComplex.repLorentzGroup.tprod LeptonSinglet.repLorentzGroup.conj.dual) + +/-- The Lorentz action on the zeroth-order lepton jet coordinate: the + contragredient conjugate spinor action. -/ +lemma JetComponentSpace.repLorentzGroup_basis_dψ_nil (Λ : SL(2,ℂ)) (α : Fin 2) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.basis (.dψ {} α)) = + ∑ β, star ((Λ⁻¹).1 α β) • JetComponentSpace.basis (.dψ {} β) := by + rw [basis_dψ_nil, + show JetComponentSpace.repLorentzGroup Λ = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.dual Λ)) + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.conj.dual Λ)) from rfl, + LinearMap.prodMap_apply, map_zero, TensorProduct.map_tmul, + DerivAlgebraComplex.repLorentzGroup_apply_one, + LeptonSinglet.repLorentzGroup_dual_dualBasis, TensorProduct.tmul_sum] + have hb : ∀ β : Fin 2, JetComponentSpace.basis + (.dψ (0 : Multiset (Fin 1 ⊕ Fin 3)) β) = + ((1 : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis β, 0) := fun β => basis_dψ_nil β + refine Prod.ext ?_ ?_ + · simp [Prod.fst_sum, hb, TensorProduct.tmul_smul] + · simp [Prod.snd_sum, hb] + +set_option maxHeartbeats 1000000 in +/-- The Lorentz action on the first-order lepton jet coordinate: the derivative + slot transforms by the columns of the Lorentz matrix and the spinor slot + contragrediently. -/ +lemma JetComponentSpace.repLorentzGroup_basis_dψ_singleton (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.basis (.dψ {μ} α)) = + ∑ ν, ∑ β, ((((Lorentz.SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * + star ((Λ⁻¹).1 α β)) • JetComponentSpace.basis (.dψ {ν} β) := by + rw [basis_dψ_singleton, + show JetComponentSpace.repLorentzGroup Λ = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.dual Λ)) + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.conj.dual Λ)) from rfl, + LinearMap.prodMap_apply, map_zero, TensorProduct.map_tmul, + DerivAlgebraComplex.repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, + LeptonSinglet.repLorentzGroup_dual_dualBasis, map_sum, TensorProduct.sum_tmul] + refine Prod.ext ?_ ?_ + · simp only [Prod.fst_sum, Prod.smul_fst, basis_dψ_singleton, map_smul, + TensorProduct.smul_tmul', TensorProduct.tmul_sum, TensorProduct.sum_tmul, + Finset.smul_sum, TensorProduct.tmul_smul, smul_smul] + refine Finset.sum_congr rfl fun ν _ => Finset.sum_congr rfl fun β _ => ?_ + rw [mul_comm] + · simp [Prod.snd_sum, basis_dψ_singleton, TensorProduct.tmul_sum, + TensorProduct.sum_tmul, map_smul, TensorProduct.smul_tmul'] + +/-- The Lorentz action on the zeroth-order conjugate lepton jet coordinate. -/ +lemma JetComponentSpace.repLorentzGroup_basis_dbarψ_nil (Λ : SL(2,ℂ)) (α : Fin 2) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.basis (.dbarψ {} α)) = + ∑ β, (Λ⁻¹).1 α β • JetComponentSpace.basis (.dbarψ {} β) := by + rw [basis_dbarψ, + show JetComponentSpace.repLorentzGroup Λ = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.dual Λ)) + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.conj.dual Λ)) from rfl, + LinearMap.prodMap_apply, map_zero, TensorProduct.map_tmul, + show DerivAlgebraComplex.basis ({} : Multiset (Fin 1 ⊕ Fin 3)) = 1 from + DerivAlgebraComplex.basis_nil, + DerivAlgebraComplex.repLorentzGroup_apply_one, + LeptonSinglet.repLorentzGroup_conj_dual_dualBasis, TensorProduct.tmul_sum] + have hb0 : DerivAlgebraComplex.basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := + DerivAlgebraComplex.basis_nil + refine Prod.ext ?_ ?_ + · simp [Prod.fst_sum, basis_dbarψ] + · simp [Prod.snd_sum, basis_dbarψ, TensorProduct.tmul_smul, hb0] + +set_option maxHeartbeats 1000000 in +/-- The Lorentz action on the first-order conjugate lepton jet coordinate. -/ +lemma JetComponentSpace.repLorentzGroup_basis_dbarψ_singleton (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.basis (.dbarψ {μ} α)) = + ∑ ν, ∑ β, ((((Lorentz.SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) * + (Λ⁻¹).1 α β) • JetComponentSpace.basis (.dbarψ {ν} β) := by + rw [basis_dbarψ, + show JetComponentSpace.repLorentzGroup Λ = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.dual Λ)) + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup Λ) + (LeptonSinglet.repLorentzGroup.conj.dual Λ)) from rfl, + LinearMap.prodMap_apply, map_zero, TensorProduct.map_tmul, + show DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = + SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) from + DerivAlgebraComplex.basis_singleton μ, + DerivAlgebraComplex.repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, + LeptonSinglet.repLorentzGroup_conj_dual_dualBasis, map_sum, + TensorProduct.sum_tmul] + refine Prod.ext ?_ ?_ + · simp [Prod.fst_sum, basis_dbarψ, TensorProduct.tmul_sum, + TensorProduct.sum_tmul, map_smul, TensorProduct.smul_tmul'] + · simp only [Prod.snd_sum, Prod.smul_snd, basis_dbarψ, + DerivAlgebraComplex.basis_singleton, map_smul, TensorProduct.smul_tmul', + TensorProduct.tmul_sum, TensorProduct.sum_tmul, Finset.smul_sum, + TensorProduct.tmul_smul, smul_smul] + refine Finset.sum_congr rfl fun ν _ => Finset.sum_congr rfl fun β _ => ?_ + rw [mul_comm] + +/-! + + +### A.1. The action of the jet gauge group + +Under the action of the gauge group +`∂_s ψ` transforms as +`∑ (x + y = s), ∂_x (star u ^ 6) ∂_y ψ`, and similarly for the conjugate. + + +-/ +/-- The action of the jet gauge group on the dual jet algebra of the + charged-lepton singlet's component functions. Component functions transform + contragrediently to the field, so the hypercharge power series is + `u ^ 6 = (star u ^ 6)⁻¹`, acting through the Leibniz rule on the dual + derivative symbols. -/ +noncomputable def dualJetAlgebraRepJetGaugeGroupI : + Representation ℂ JetGaugeGroupI DerivAlgebraComplex where + toFun U := DerivAlgebraComplex.jetRingAction (((U.2.2 : unitary JetRing) : JetRing) ^ 6) + map_one' := by + rw [show (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) ^ 6 = + (1 : JetRing) by simp, DerivAlgebraComplex.jetRingAction_one] + rfl + map_mul' U₁ U₂ := by + rw [show (((U₁ * U₂ : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) ^ 6 = + ((U₁.2.2 : unitary JetRing) : JetRing) ^ 6 * + ((U₂.2.2 : unitary JetRing) : JetRing) ^ 6 by + rw [show (((U₁ * U₂ : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, mul_pow], + DerivAlgebraComplex.jetRingAction_mul, Module.End.mul_eq_comp] + +/-- The action of the jet gauge group on the dual jet algebra of the conjugate + charged-lepton singlet's component functions: the conjugate components + transform with the conjugate-contragredient hypercharge power series + `star u ^ 6`. -/ +noncomputable def dualJetAlgebraRepJetGaugeGroupIConj : + Representation ℂ JetGaugeGroupI + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) where + toFun U := DerivAlgebraComplex.jetRingAction ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6) + map_one' := by + rw [show (star (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing)) ^ 6 = + (1 : JetRing) by simp, DerivAlgebraComplex.jetRingAction_one] + rfl + map_mul' U₁ U₂ := by + rw [show (star (((U₁ * U₂ : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing)) ^ 6 = + (star ((U₁.2.2 : unitary JetRing) : JetRing)) ^ 6 * + (star ((U₂.2.2 : unitary JetRing) : JetRing)) ^ 6 by + rw [show (((U₁ * U₂ : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, star_mul', mul_pow], + DerivAlgebraComplex.jetRingAction_mul, Module.End.mul_eq_comp] + +@[simp] +lemma dualJetAlgebraRepJetGaugeGroupI_apply (U : JetGaugeGroupI) : + dualJetAlgebraRepJetGaugeGroupI U = + DerivAlgebraComplex.jetRingAction (((U.2.2 : unitary JetRing) : JetRing) ^ 6) := rfl + +@[simp] +lemma dualJetAlgebraRepJetGaugeGroupIConj_apply (U : JetGaugeGroupI) : + dualJetAlgebraRepJetGaugeGroupIConj U = + DerivAlgebraComplex.jetRingAction ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6) := rfl + +/-- The `(1, 1)_{-6}` action of the jet gauge group on the space of component + functions of the charged-lepton singlet, its conjugate, and their derivative + coordinates. The conventions are contragredient, matching the `.dual` and + `.conj.dual` conventions of the global component-space representations: the + singlet components transform through the derivative action of `u ^ 6`, the + conjugate components through the derivative action of `star u ^ 6`, and the + target factors are inert. On jets of constant gauge transformations the + derivative symbols are inert and the action reduces to the dual global gauge + action. -/ +noncomputable def JetComponentSpace.repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI JetComponentSpace := + (dualJetAlgebraRepJetGaugeGroupI.tprod + (Representation.trivial ℂ JetGaugeGroupI (Module.Dual ℂ LeptonSinglet))).prod + (dualJetAlgebraRepJetGaugeGroupIConj.tprod + (Representation.trivial ℂ JetGaugeGroupI (Module.Dual ℂ (ConjModule LeptonSinglet)))) + +/-- The jet gauge action preserves the unconjugated half of the component space, + acting there by the dual derivative action of the contragredient hypercharge + power series on the derivative symbols. -/ +lemma JetComponentSpace.repJetGaugeGroupI_inl (U : JetGaugeGroupI) + (a : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) + (φ : Module.Dual ℂ LeptonSinglet) : + JetComponentSpace.repJetGaugeGroupI U ((a ⊗ₜ[ℂ] φ, 0) : JetComponentSpace) = + ((DerivAlgebraComplex.jetRingAction (((U.2.2 : unitary JetRing) : JetRing) ^ 6) a) ⊗ₜ[ℂ] φ, 0) := by + refine Prod.ext ?_ ?_ <;> + simp [JetComponentSpace.repJetGaugeGroupI, Representation.prod_apply_apply, + Representation.tprod_apply, dualJetAlgebraRepJetGaugeGroupI_apply] + +/-- The jet gauge action on a general element of the unconjugated half of the + component space. -/ +lemma JetComponentSpace.repJetGaugeGroupI_inl' (U : JetGaugeGroupI) + (y : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet) : + JetComponentSpace.repJetGaugeGroupI U ((y, 0) : JetComponentSpace) = + ((TensorProduct.map (DerivAlgebraComplex.jetRingAction (((U.2.2 : unitary JetRing) : JetRing) ^ 6)) + LinearMap.id) y, 0) := by + induction y using TensorProduct.induction_on with + | zero => + rw [show ((0, 0) : JetComponentSpace) = 0 from rfl, map_zero, map_zero] + rfl + | add a b ha hb => + have hpair : ((a + b, 0) : JetComponentSpace) = (a, 0) + (b, 0) := by + simp + rw [hpair, map_add, ha, hb, map_add] + simp + | tmul a φ => + rw [JetComponentSpace.repJetGaugeGroupI_inl, TensorProduct.map_tmul] + rfl + +/-- The jet gauge action preserves the conjugated half of the component space, + acting there by the dual derivative action of the conjugate-contragredient + hypercharge power series on the derivative symbols. -/ +lemma JetComponentSpace.repJetGaugeGroupI_inr (U : JetGaugeGroupI) + (a : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + JetComponentSpace.repJetGaugeGroupI U ((0, a ⊗ₜ[ℂ] φ) : JetComponentSpace) = + (0, (DerivAlgebraComplex.jetRingAction + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6) a) ⊗ₜ[ℂ] φ) := by + refine Prod.ext ?_ ?_ <;> + simp [JetComponentSpace.repJetGaugeGroupI, Representation.prod_apply_apply, + Representation.tprod_apply, dualJetAlgebraRepJetGaugeGroupIConj_apply] + +/-- The jet gauge action on a general element of the conjugated half of the + component space. -/ +lemma JetComponentSpace.repJetGaugeGroupI_inr' (U : JetGaugeGroupI) + (y : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet)) : + JetComponentSpace.repJetGaugeGroupI U ((0, y) : JetComponentSpace) = + (0, (TensorProduct.map (DerivAlgebraComplex.jetRingAction + ((star ((U.2.2 : unitary JetRing) : JetRing)) ^ 6)) LinearMap.id) y) := by + induction y using TensorProduct.induction_on with + | zero => + rw [show ((0, 0) : JetComponentSpace) = 0 from rfl, map_zero, map_zero] + rfl + | add a b ha hb => + have hpair : ((0, a + b) : JetComponentSpace) = (0, a) + (0, b) := by + simp + rw [hpair, map_add, ha, hb, map_add] + simp + | tmul a φ => + rw [JetComponentSpace.repJetGaugeGroupI_inr, TensorProduct.map_tmul] + rfl + +open MvPowerSeries in +/-- The gauge action on a lepton jet coordinate is the Leibniz expansion of + `∂_t (u⁶ ψ)`: a sum over the splittings `t = x + y` of the `x`-th Taylor + coefficient of the hypercharge character `u⁶` against the `y`-th coordinate. + The weight `∏ descFactorial` together with `coeff x χ = (∂_x χ)(0) / x!` + makes up the multi-index binomial coefficient `(t choose x)`. -/ +lemma JetComponentSpace.repJetGaugeGroupI_basis_dψ (U : JetGaugeGroupI) + (t : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + repJetGaugeGroupI U (basis (.dψ t α)) = + ∑ p ∈ Finset.antidiagonal t.toFinsupp, + ((∏ μ, (t.toFinsupp μ).descFactorial (p.1 μ) : ℕ) : ℂ) • + coeff p.1 (((U.2.2 : unitary JetRing) : JetRing) ^ 6) • + basis (.dψ (Multiset.toFinsupp.symm p.2) α) := by + have hb : ∀ p : (Fin 1 ⊕ Fin 3) →₀ ℕ, + JetComponentSpace.basis (.dψ (Multiset.toFinsupp.symm p) α) = + ((Lorentz.complexCoBasis.dualBasis.symmetricAlgebra p ⊗ₜ[ℂ] + LeptonSinglet.basis.dualBasis α), 0) := by + intro p + rw [JetComponentSpace.basis_dψ, DerivAlgebraComplex.basis_apply, + AddEquiv.apply_symm_apply] + rw [JetComponentSpace.basis_dψ, JetComponentSpace.repJetGaugeGroupI_inl, + DerivAlgebraComplex.basis_apply, DerivAlgebraComplex.jetRingAction_basis, + TensorProduct.sum_tmul, + show ∀ v : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet, + ((v, 0) : JetComponentSpace) = LinearMap.inl ℂ _ _ v from fun _ => rfl, + map_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [hb p.2, ← TensorProduct.smul_tmul', ← TensorProduct.smul_tmul', + map_smul, map_smul] + rfl + +open MvPowerSeries in +/-- The gauge action on the first-order lepton coordinate: the character at the + base point acts on the coordinate itself, and its first Taylor coefficient + feeds into the zeroth-order coordinate. This is the `t = {μ}` case of + `repJetGaugeGroupI_basis_dψ`. -/ +lemma JetComponentSpace.repJetGaugeGroupI_basis_dψ_singleton (U : JetGaugeGroupI) + (μ : Fin 1 ⊕ Fin 3) (α : Fin 2) : + repJetGaugeGroupI U (basis (.dψ {μ} α)) = + constantCoeff (((U.2.2 : unitary JetRing) : JetRing) ^ 6) • + basis (.dψ {μ} α) + + coeff (Finsupp.single μ 1) (((U.2.2 : unitary JetRing) : JetRing) ^ 6) • + basis (.dψ {} α) := by + classical + have hm : ({μ} : Multiset (Fin 1 ⊕ Fin 3)).toFinsupp = Finsupp.single μ 1 := by + simp + rw [JetComponentSpace.repJetGaugeGroupI_basis_dψ, hm, Finsupp.antidiagonal_single, + show Finset.antidiagonal (1 : ℕ) = {(0, 1), (1, 0)} from by decide, + Finset.map_insert, Finset.map_singleton, + Finset.sum_insert (by simp [Finsupp.single_eq_zero]), Finset.sum_singleton] + simp only [Function.Embedding.coe_prodMap, Function.Embedding.coeFn_mk, + Prod.map_apply, Finsupp.single_zero, coeff_zero_eq_constantCoeff, + Nat.descFactorial_zero, Finset.prod_const_one, Nat.cast_one, one_smul, + Nat.descFactorial_self] + have hw1 : (∏ x, ((Finsupp.single μ 1 : (Fin 1 ⊕ Fin 3) →₀ ℕ) x).descFactorial + ((0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) x) : ℕ) = 1 := by simp + have hw2 : (∏ x, ((Finsupp.single μ 1 : (Fin 1 ⊕ Fin 3) →₀ ℕ) x).factorial : ℕ) + = 1 := by + refine Finset.prod_eq_one fun x _ => ?_ + rcases eq_or_ne μ x with rfl | h + · simp + · simp only [Finsupp.single_apply, if_neg h, Nat.factorial_zero] + have htf1 : Multiset.toFinsupp.symm (Finsupp.single μ 1) = + ({μ} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [← hm, AddEquiv.symm_apply_apply] + have htf0 : Multiset.toFinsupp.symm (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + (0 : Multiset (Fin 1 ⊕ Fin 3)) := map_zero _ + rw [hw1, hw2, htf1, htf0] + simp + +/-! + +## B. The formal total derivative on the component functions + +The formal total spacetime derivative `∂_μ` acts on the component functions of +the charged-lepton jet by appending the derivative index, +`∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α`, and likewise on the conjugate components. + +-/ + +namespace JetGenerators + +/-- The jet generator with one further derivative in the direction `μ`. -/ +def shift (μ : Fin 1 ⊕ Fin 3) : JetGenerators → JetGenerators + | dψ s α => dψ (s + {μ}) α + | dbarψ s α => dbarψ (s + {μ}) α + +@[simp] +lemma shift_dψ (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + shift μ (dψ s α) = dψ (s + {μ}) α := rfl + +@[simp] +lemma shift_dbarψ (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (α : Fin 2) : + shift μ (dbarψ s α) = dbarψ (s + {μ}) α := rfl + +/-- Appending a derivative index raises the mass weight by two: a derivative has + mass dimension one. -/ +@[simp] +lemma massWeight_shift (μ : Fin 1 ⊕ Fin 3) (j : JetGenerators) : + (shift μ j).massWeight = j.massWeight + 2 := by + cases j <;> simp [shift, massWeight] <;> omega + +end JetGenerators + +/-- The formal total spacetime derivative on the space of component functions of + the charged-lepton singlet in the direction `μ`: the shift + `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the derivative multi-index, and likewise on the + conjugate components. -/ +noncomputable def JetComponentSpace.jetDeriv (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace →ₗ[ℂ] JetComponentSpace := + JetComponentSpace.basis.constr ℂ fun j => + JetComponentSpace.basis (JetGenerators.shift μ j) + +@[simp] +lemma JetComponentSpace.jetDeriv_basis (μ : Fin 1 ⊕ Fin 3) (j : JetGenerators) : + JetComponentSpace.jetDeriv μ (JetComponentSpace.basis j) = + JetComponentSpace.basis (JetGenerators.shift μ j) := by + rw [JetComponentSpace.jetDeriv, Module.Basis.constr_basis] + +lemma JetComponentSpace.jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) (v : JetComponentSpace) : + JetComponentSpace.jetDeriv μ (JetComponentSpace.jetDeriv ν v) = + JetComponentSpace.jetDeriv ν (JetComponentSpace.jetDeriv μ v) := by + have h : JetComponentSpace.jetDeriv μ ∘ₗ JetComponentSpace.jetDeriv ν = + JetComponentSpace.jetDeriv ν ∘ₗ JetComponentSpace.jetDeriv μ := by + refine JetComponentSpace.basis.ext fun j => ?_ + simp [LinearMap.coe_comp, Function.comp_apply, JetComponentSpace.jetDeriv_basis, + JetGenerators.shift, ] + grind + exact DFunLike.congr_fun h v + +/-- The total derivative acts on each factor of the component space as multiplication by the + derivative symbol `∂_μ` on the dual jet algebra, leaving the spinor factor alone. -/ +lemma JetComponentSpace.jetDeriv_eq_prodMap (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace.jetDeriv μ = + LinearMap.prodMap + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) := by + refine JetComponentSpace.basis.ext fun j => ?_ + match j with + | .dψ s α => + rw [JetComponentSpace.jetDeriv_basis] + show JetComponentSpace.basis (.dψ (s + {μ}) α) = _ + rw [JetComponentSpace.basis_dψ, JetComponentSpace.basis_dψ] + refine Prod.ext ?_ ?_ + · simp only [LinearMap.prodMap_apply, TensorProduct.map_tmul, LinearMap.mulRight_apply, + LinearMap.id_apply, DerivAlgebraComplex.basis_mul] + · simp only [LinearMap.prodMap_apply, map_zero] + | .dbarψ s α => + rw [JetComponentSpace.jetDeriv_basis] + show JetComponentSpace.basis (.dbarψ (s + {μ}) α) = _ + rw [JetComponentSpace.basis_dbarψ, JetComponentSpace.basis_dbarψ] + refine Prod.ext ?_ ?_ + · simp only [LinearMap.prodMap_apply, map_zero] + · simp only [LinearMap.prodMap_apply, TensorProduct.map_tmul, LinearMap.mulRight_apply, + LinearMap.id_apply, DerivAlgebraComplex.basis_mul] + +lemma JetComponentSpace.jetDeriv_fst (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace) : + (JetComponentSpace.jetDeriv μ v).1 = + TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id v.1 := by + rw [JetComponentSpace.jetDeriv_eq_prodMap]; rfl + +lemma JetComponentSpace.jetDeriv_snd (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace) : + (JetComponentSpace.jetDeriv μ v).2 = + TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id v.2 := by + rw [JetComponentSpace.jetDeriv_eq_prodMap]; rfl + +lemma JetComponentSpace.repLorentzGroup_fst (Λ : SL(2,ℂ)) (v : JetComponentSpace) : + (JetComponentSpace.repLorentzGroup Λ v).1 = + (DerivAlgebraComplex.repLorentzGroup.tprod LeptonSinglet.repLorentzGroup.dual) Λ v.1 := + rfl + +lemma JetComponentSpace.repLorentzGroup_snd (Λ : SL(2,ℂ)) (v : JetComponentSpace) : + (JetComponentSpace.repLorentzGroup Λ v).2 = + (DerivAlgebraComplex.repLorentzGroup.tprod + LeptonSinglet.repLorentzGroup.conj.dual) Λ v.2 := + rfl + +/-- The covariance of the derivative-symbol multiplication on one tensor factor of the + component space, for an arbitrary representation on the other factor. -/ +private lemma repLorentzGroup_tprod_mulRight_jetSymbol {W : Type*} [AddCommGroup W] + [Module ℂ W] (ρ : Representation ℂ SL(2,ℂ) W) (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (w : DerivAlgebraComplex ⊗[ℂ] W) : + (DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id w) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id ((DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ w) := by + have hsym : DerivAlgebraComplex.repLorentzGroup Λ + (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + DerivAlgebraComplex.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [DerivAlgebraComplex.basis_singleton, DerivAlgebraComplex.repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, DerivAlgebraComplex.basis_singleton] + have hrep : ∀ (q : DerivAlgebraComplex) (f : W), + (DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ (q ⊗ₜ[ℂ] f) = + (DerivAlgebraComplex.repLorentzGroup Λ q) ⊗ₜ[ℂ] (ρ Λ f) := fun _ _ => rfl + induction w using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => + rw [map_add, map_add, map_add, hx, hy, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + | tmul q f => + rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, LinearMap.id_apply, hrep, hrep, + DerivAlgebraComplex.repLorentzGroup_apply_mul, hsym, Finset.mul_sum, + TensorProduct.sum_tmul] + exact Finset.sum_congr rfl fun a _ => by + rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, LinearMap.id_apply, + mul_smul_comm, TensorProduct.smul_tmul'] + +/-- **The shift is Lorentz covariant on the component space.** Appending `∂_μ` and then acting + is acting and then appending the transformed `∂_μ`, which is a combination of the `∂_a`. -/ +lemma JetComponentSpace.repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.jetDeriv μ v) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + JetComponentSpace.jetDeriv a (JetComponentSpace.repLorentzGroup Λ v) := by + refine Prod.ext ?_ ?_ + · simp only [Prod.fst_sum, Prod.smul_fst, JetComponentSpace.repLorentzGroup_fst, + JetComponentSpace.jetDeriv_fst] + exact repLorentzGroup_tprod_mulRight_jetSymbol _ Λ μ v.1 + · simp only [Prod.snd_sum, Prod.smul_snd, JetComponentSpace.repLorentzGroup_snd, + JetComponentSpace.jetDeriv_snd] + exact repLorentzGroup_tprod_mulRight_jetSymbol _ Λ μ v.2 + +/-! + +## C. The mass-weight scaling on the component functions + +-/ + +/-- The mass-dimension scaling on the space of component functions of the + charged-lepton singlet: the diagonal map multiplying each component function + `∂_s ψ_α` by `c ^ w`, where `w` is twice its mass dimension. -/ +noncomputable def JetComponentSpace.massWeightScale (c : ℂ) : + JetComponentSpace →ₗ[ℂ] JetComponentSpace := + JetComponentSpace.basis.constr ℂ fun j => + c ^ j.massWeight • JetComponentSpace.basis j + +@[simp] +lemma JetComponentSpace.massWeightScale_basis (c : ℂ) (j : JetGenerators) : + JetComponentSpace.massWeightScale c (JetComponentSpace.basis j) = + c ^ j.massWeight • JetComponentSpace.basis j := by + rw [JetComponentSpace.massWeightScale, Module.Basis.constr_basis] + +/-- The total derivative raises the mass weight by two on the component space: + the scaling and the derivative commute up to `c ^ 2`. -/ +lemma JetComponentSpace.massWeightScale_jetDeriv (c : ℂ) (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace) : + JetComponentSpace.massWeightScale c (JetComponentSpace.jetDeriv μ v) = + c ^ 2 • JetComponentSpace.jetDeriv μ (JetComponentSpace.massWeightScale c v) := by + have h : JetComponentSpace.massWeightScale c ∘ₗ JetComponentSpace.jetDeriv μ = + c ^ 2 • (JetComponentSpace.jetDeriv μ ∘ₗ JetComponentSpace.massWeightScale c) := by + refine JetComponentSpace.basis.ext fun j => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.smul_apply, + JetComponentSpace.jetDeriv_basis, JetComponentSpace.massWeightScale_basis, + map_smul, JetGenerators.massWeight_shift, smul_smul, ← pow_add] + congr 1 + ring + exact DFunLike.congr_fun h v + +/-- The mass-dimension scaling commutes with the action of jets of constant + gauge transformations on the component space: the constant action is diagonal + on the generator basis, with no derivative mixing. For a non-constant jet the + higher Taylor coefficients of `u ^ 6` strictly lower the derivative degree, so + the action does not commute with the scaling. -/ +lemma JetComponentSpace.massWeightScale_repJetGaugeGroupI_ofConstant (c : ℂ) (g : GaugeGroupI) : + JetComponentSpace.massWeightScale c ∘ₗ + JetComponentSpace.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + JetComponentSpace.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) ∘ₗ + JetComponentSpace.massWeightScale c := by + have hu : ((((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing)) : JetRing) = + MvPowerSeries.C ((g.2.2 : ℂ)) := rfl + refine JetComponentSpace.basis.ext fun j => ?_ + cases j with + | dψ s α => + have hrep : JetComponentSpace.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) + (JetComponentSpace.basis (.dψ s α)) = + ((g.2.2 : ℂ) ^ 6) • JetComponentSpace.basis (.dψ s α) := by + simp only [JetComponentSpace.basis_dψ] + rw [JetComponentSpace.repJetGaugeGroupI_inl, hu, ← map_pow, + DerivAlgebraComplex.jetRingAction_C] + simp [TensorProduct.smul_tmul', Prod.smul_mk] + simp only [LinearMap.coe_comp, Function.comp_apply, hrep, map_smul, + JetComponentSpace.massWeightScale_basis] + exact smul_comm _ _ _ + | dbarψ s α => + have hrep : JetComponentSpace.repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) + (JetComponentSpace.basis (.dbarψ s α)) = + ((star (g.2.2 : ℂ)) ^ 6) • JetComponentSpace.basis (.dbarψ s α) := by + simp only [JetComponentSpace.basis_dbarψ] + rw [JetComponentSpace.repJetGaugeGroupI_inr, hu, JetRing.star_C, ← map_pow, + DerivAlgebraComplex.jetRingAction_C] + simp [TensorProduct.smul_tmul', Prod.smul_mk] + simp only [LinearMap.coe_comp, Function.comp_apply, hrep, map_smul, + JetComponentSpace.massWeightScale_basis] + exact smul_comm _ _ _ + +/-- The mass-dimension scaling commutes with the Lorentz action on the component + space: the Lorentz action mixes derivative symbols and spinor components only + within a fixed derivative degree, on which the scaling is a scalar. -/ +lemma JetComponentSpace.massWeightScale_repLorentzGroup (c : ℂ) (g : SL(2,ℂ)) : + JetComponentSpace.massWeightScale c ∘ₗ JetComponentSpace.repLorentzGroup g = + JetComponentSpace.repLorentzGroup g ∘ₗ JetComponentSpace.massWeightScale c := by + have hfact : JetComponentSpace.massWeightScale c = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id)) + (TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id)) := by + refine JetComponentSpace.basis.ext fun j => ?_ + cases j with + | dψ s α => + have hscal : (c : ℂ) ^ (JetGenerators.dψ s α).massWeight = + c ^ 3 * (c ^ 2) ^ s.card := by + show c ^ (3 + 2 * s.card) = _ + ring + rw [JetComponentSpace.massWeightScale_basis, hscal] + simp only [JetComponentSpace.basis_dψ, LinearMap.prodMap_apply, map_zero, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, LinearMap.smul_apply, + LinearMap.id_apply, DerivAlgebraComplex.gradeScale_basis, + TensorProduct.tmul_smul, TensorProduct.smul_tmul', Prod.smul_mk, smul_smul, + smul_zero] + | dbarψ s α => + have hscal : (c : ℂ) ^ (JetGenerators.dbarψ s α).massWeight = + c ^ 3 * (c ^ 2) ^ s.card := by + show c ^ (3 + 2 * s.card) = _ + ring + rw [JetComponentSpace.massWeightScale_basis, hscal] + simp only [JetComponentSpace.basis_dbarψ, LinearMap.prodMap_apply, map_zero, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, LinearMap.smul_apply, + LinearMap.id_apply, DerivAlgebraComplex.gradeScale_basis, + TensorProduct.tmul_smul, TensorProduct.smul_tmul', Prod.smul_mk, smul_smul, + smul_zero] + have hA : (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap ∘ₗ + DerivAlgebraComplex.repLorentzGroup g = + (DerivAlgebraComplex.repLorentzGroup g : + DerivAlgebraComplex →ₗ[ℂ] DerivAlgebraComplex) ∘ₗ + (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap := + LinearMap.ext fun a => DerivAlgebraComplex.gradeScale_repLorentzGroup (c ^ 2) g a + have hB1 : (c ^ 3 • (LinearMap.id : Module.End ℂ (Module.Dual ℂ LeptonSinglet))) ∘ₗ + LeptonSinglet.repLorentzGroup.dual g = + LeptonSinglet.repLorentzGroup.dual g ∘ₗ (c ^ 3 • LinearMap.id) := by + rw [LinearMap.smul_comp, LinearMap.comp_smul, LinearMap.id_comp, LinearMap.comp_id] + have hB2 : (c ^ 3 • (LinearMap.id : + Module.End ℂ (Module.Dual ℂ (ConjModule LeptonSinglet)))) ∘ₗ + LeptonSinglet.repLorentzGroup.conj.dual g = + LeptonSinglet.repLorentzGroup.conj.dual g ∘ₗ (c ^ 3 • LinearMap.id) := by + rw [LinearMap.smul_comp, LinearMap.comp_smul, LinearMap.id_comp, LinearMap.comp_id] + have hcomp1 : TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id) ∘ₗ + TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.dual g) = + TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.dual g) ∘ₗ + TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id) := by + rw [← TensorProduct.map_comp, ← TensorProduct.map_comp, hA, hB1] + have hcomp2 : TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id) ∘ₗ + TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.conj.dual g) = + TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.conj.dual g) ∘ₗ + TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + (c ^ 3 • LinearMap.id) := by + rw [← TensorProduct.map_comp, ← TensorProduct.map_comp, hA, hB2] + rw [hfact, show JetComponentSpace.repLorentzGroup g = + LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.dual g)) + (TensorProduct.map (DerivAlgebraComplex.repLorentzGroup g) + (LeptonSinglet.repLorentzGroup.conj.dual g)) from rfl] + refine LinearMap.ext fun x => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.prodMap_apply] + exact Prod.ext (DFunLike.congr_fun hcomp1 x.1) (DFunLike.congr_fun hcomp2 x.2) + +/-! + +## D. The total derivative on the summands of the component space + +-/ + +/-- The total derivative preserves the unconjugated half of the component space, + acting there by the shift of dual derivative symbols. -/ +lemma JetComponentSpace.jetDeriv_inl (μ : Fin 1 ⊕ Fin 3) + (a : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) + (φ : Module.Dual ℂ LeptonSinglet) : + JetComponentSpace.jetDeriv μ ((a ⊗ₜ[ℂ] φ, 0) : JetComponentSpace) = + ((DerivAlgebraComplex.deriv μ a) ⊗ₜ[ℂ] φ, 0) := by + have h : (JetComponentSpace.jetDeriv μ) ∘ₗ (LinearMap.inl ℂ + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet) + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet))) = + (LinearMap.inl ℂ _ _) ∘ₗ (TensorProduct.map (DerivAlgebraComplex.deriv μ) LinearMap.id) := by + refine (DerivAlgebraComplex.basis.tensorProduct LeptonSinglet.basis.dualBasis).ext + fun p => ?_ + obtain ⟨s, α⟩ := p + rw [Module.Basis.tensorProduct_apply'] + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.inl_apply, + TensorProduct.map_tmul, LinearMap.id_coe, id_eq] + rw [show ((DerivAlgebraComplex.basis s ⊗ₜ[ℂ] LeptonSinglet.basis.dualBasis α, 0) : + JetComponentSpace) = JetComponentSpace.basis (.dψ s α) from + (JetComponentSpace.basis_dψ s α).symm, + JetComponentSpace.jetDeriv_basis, JetGenerators.shift_dψ, + JetComponentSpace.basis_dψ, DerivAlgebraComplex.deriv_basis_multiset] + have h1 := LinearMap.congr_fun h (a ⊗ₜ[ℂ] φ) + simpa using h1 + +/-- The total derivative on a general element of the unconjugated half of the + component space. -/ +lemma JetComponentSpace.jetDeriv_inl' (μ : Fin 1 ⊕ Fin 3) + (y : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet) : + JetComponentSpace.jetDeriv μ ((y, 0) : JetComponentSpace) = + ((TensorProduct.map (DerivAlgebraComplex.deriv μ) LinearMap.id) y, 0) := by + induction y using TensorProduct.induction_on with + | zero => + rw [show ((0, 0) : JetComponentSpace) = 0 from rfl, map_zero, map_zero] + rfl + | add a b ha hb => + have hpair : ((a + b, 0) : JetComponentSpace) = (a, 0) + (b, 0) := by + simp + rw [hpair, map_add, ha, hb, map_add] + simp + | tmul a φ => + rw [JetComponentSpace.jetDeriv_inl, TensorProduct.map_tmul] + rfl + +/-- The total derivative preserves the conjugated half of the component space, + acting there by the shift of dual derivative symbols. -/ +lemma JetComponentSpace.jetDeriv_inr (μ : Fin 1 ⊕ Fin 3) + (a : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : + JetComponentSpace.jetDeriv μ ((0, a ⊗ₜ[ℂ] φ) : JetComponentSpace) = + (0, (DerivAlgebraComplex.deriv μ a) ⊗ₜ[ℂ] φ) := by + have h : (JetComponentSpace.jetDeriv μ) ∘ₗ (LinearMap.inr ℂ + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ LeptonSinglet) + (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet))) = + (LinearMap.inr ℂ _ _) ∘ₗ (TensorProduct.map (DerivAlgebraComplex.deriv μ) + LinearMap.id) := by + refine (DerivAlgebraComplex.basis.tensorProduct + (LeptonSinglet.basis.conj.dualBasis)).ext fun p => ?_ + obtain ⟨s, α⟩ := p + rw [Module.Basis.tensorProduct_apply'] + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.inr_apply, + TensorProduct.map_tmul, LinearMap.id_coe, id_eq] + rw [show ((0, DerivAlgebraComplex.basis s ⊗ₜ[ℂ] + LeptonSinglet.basis.conj.dualBasis α) : JetComponentSpace) = + JetComponentSpace.basis (.dbarψ s α) from + (JetComponentSpace.basis_dbarψ s α).symm, + JetComponentSpace.jetDeriv_basis, JetGenerators.shift_dbarψ, + JetComponentSpace.basis_dbarψ, DerivAlgebraComplex.deriv_basis_multiset] + have h1 := LinearMap.congr_fun h (a ⊗ₜ[ℂ] φ) + simpa using h1 + +/-- The total derivative on a general element of the conjugated half of the + component space. -/ +lemma JetComponentSpace.jetDeriv_inr' (μ : Fin 1 ⊕ Fin 3) + (y : SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) ⊗[ℂ] + Module.Dual ℂ (ConjModule LeptonSinglet)) : + JetComponentSpace.jetDeriv μ ((0, y) : JetComponentSpace) = + (0, (TensorProduct.map (DerivAlgebraComplex.deriv μ) LinearMap.id) y) := by + induction y using TensorProduct.induction_on with + | zero => + rw [show ((0, 0) : JetComponentSpace) = 0 from rfl, map_zero, map_zero] + rfl + | add a b ha hb => + have hpair : ((0, a + b) : JetComponentSpace) = (0, a) + (0, b) := by + simp + rw [hpair, map_add, ha, hb, map_add] + simp + | tmul a φ => + rw [JetComponentSpace.jetDeriv_inr, TensorProduct.map_tmul] + rfl + +end LeptonSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean index 953a4aefe..e427e87e9 100644 --- a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean +++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet.lean @@ -6,10 +6,16 @@ Authors: Joseph Tooby-Smith module public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv public import Physlib.Relativity.Fermions.Weyl.LeftHanded public import Physlib.Relativity.Fermions.Weyl.RightHanded public import Physlib.Relativity.Fermions.Weyl.DualLeftHanded public import Physlib.Relativity.Fermions.Weyl.DualRightHanded +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.LinearAlgebra.Matrix.Kronecker +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps /-! # The type corresponding to quark doublets @@ -27,10 +33,6 @@ namespace StandardModel open TensorProduct -TODO "Add other fermions similar to this file with the names: - - UpSinglet (3, 1)_{4} (right-handed) - - LeptonSinglet (1, 1)_{-6} (right-handed)" - /-- The vector space of a quark field in the Standard Model. These live in the (3, 2)_{1} representation of the gauge group. -/ @[ext] @@ -84,6 +86,24 @@ lemma val_add (q1 q2 : QuarkDoublet) : (q1 + q2).val = q1.val + q2.val := rfl @[simp] lemma val_smul (r : ℂ) (q : QuarkDoublet) : (r • q).val = r • q.val := rfl + +/-! + +## The basis of the quark doublet space + +-/ + +/-- A basis on the quark doublets. -/ +noncomputable def basis : Module.Basis (Fin 2 × Fin 3 × Fin 2) ℂ QuarkDoublet := + ((((Fermion.LeftHandedWeyl.basis.tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).tensorProduct + (EuclideanSpace.basisFun (Fin 2) ℂ).toBasis).map valLinEquiv.symm).reindex + (Equiv.prodAssoc (Fin 2) (Fin 3) (Fin 2))) + +instance : Module.Finite ℂ QuarkDoublet := Module.Finite.of_basis basis + +instance : Module.Free ℂ QuarkDoublet := Module.Free.of_basis basis + /-! ## Lorentz group representation @@ -237,6 +257,277 @@ noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂) | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃) +/-! + +## The representation of the jet gauge group + +The colour and weak indices are combined into the single index `Fin 3 × Fin 2`, on which +the `SU(3)` and `SU(2)` power-series matrices of a jet of gauge transformations act +together through their Kronecker product, scaled by the hypercharge power series `u`. + +-/ + +open Kronecker + +/-- The colour and weak factors of the quark doublet combined into a single Euclidean +factor over `Fin 3 × Fin 2`. -/ +noncomputable def colourWeakEquiv : + EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2) ≃ₗ[ℂ] (Fin 3 × Fin 2 → ℂ) := + (TensorProduct.congr (WithLp.linearEquiv 2 ℂ (Fin 3 → ℂ)) + (WithLp.linearEquiv 2 ℂ (Fin 2 → ℂ))).trans <| + (TensorProduct.piScalarRight ℂ ℂ (Fin 3 → ℂ) (Fin 2)).trans <| + (LinearEquiv.curry ℂ ℂ (Fin 2) (Fin 3)).symm.trans <| + LinearEquiv.piCongrLeft' ℂ (fun _ => ℂ) (Equiv.prodComm (Fin 2) (Fin 3)) + +@[simp] +lemma colourWeakEquiv_tmul (c : EuclideanSpace ℂ (Fin 3)) (w : EuclideanSpace ℂ (Fin 2)) + (p : Fin 3 × Fin 2) : + colourWeakEquiv (c ⊗ₜ[ℂ] w) p = c.ofLp p.1 * w.ofLp p.2 := by + simp [colourWeakEquiv, Function.uncurry, Algebra.algebraMap_eq_smul_one, mul_comm] + +/-- Absorbs the jet ring into the combined colour–weak index: a jet of a quark doublet is +the same thing as a left-handed Weyl spinor tensored with a `JetRing`-valued +colour–weak vector, + + `JetRing ⊗[ℂ] QuarkDoublet ≃ LeftHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3 × Fin 2)`. + +-/ +noncomputable def jetValLinEquiv : + JetRing ⊗[ℂ] QuarkDoublet ≃ₗ[ℂ] + Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3 × Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) + (valLinEquiv.trans (TensorProduct.assoc ℂ Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 3)) (EuclideanSpace ℂ (Fin 2))))).trans <| + (TensorProduct.leftComm ℂ JetRing Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 3) ⊗[ℂ] EuclideanSpace ℂ (Fin 2))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.LeftHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) colourWeakEquiv).trans <| + ((TensorProduct.piScalarRight ℂ JetRing JetRing (Fin 3 × Fin 2)).trans + (WithLp.linearEquiv 2 JetRing (Fin 3 × Fin 2 → JetRing)).symm).restrictScalars ℂ + +/-- The matrix of jets through which a jet of gauge transformations acts on the combined +colour–weak index of the quark doublet: the Kronecker product of the `SU(3)` and `SU(2)` +power-series matrices, scaled by the hypercharge power series `u`. -/ +noncomputable def jetGaugeMatrix (U : JetGaugeGroupI) : + Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) JetRing := + ((U.2.2 : unitary JetRing) : JetRing) • + (((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing)) + +lemma jetGaugeMatrix_one : jetGaugeMatrix 1 = 1 := by + rw [jetGaugeMatrix, + show (((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) = 1 from rfl, + show ((((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) JetRing)) : + Matrix (Fin 3) (Fin 3) JetRing) = 1 from rfl, + show ((((1 : JetGaugeGroupI).2.1 : specialUnitaryGroup (Fin 2) JetRing)) : + Matrix (Fin 2) (Fin 2) JetRing) = 1 from rfl, + Matrix.one_kronecker_one, one_smul] + +lemma jetGaugeMatrix_mul (U₁ U₂ : JetGaugeGroupI) : + jetGaugeMatrix (U₁ * U₂) = jetGaugeMatrix U₁ * jetGaugeMatrix U₂ := by + rw [jetGaugeMatrix, jetGaugeMatrix, jetGaugeMatrix, + show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) = + ((U₁.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) * + ((U₂.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + from rfl, + show (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) = + ((U₁.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) * + ((U₂.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + from rfl, + Matrix.mul_kronecker_mul, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + +/-- The `(3, 2)_{1}` action of the jet gauge group on the jet space of the quark doublet. +Through `jetValLinEquiv` the Kronecker matrix of the gauge jet, carrying the hypercharge +phase `u`, acts `JetRing`-linearly on the combined colour–weak factor by matrix-vector +multiplication, while the Weyl factor is untouched. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] QuarkDoublet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End JetRing + (EuclideanSpace JetRing (Fin 3 × Fin 2))).restrictScalars ℂ = 1 := rfl + rw [jetGaugeMatrix_one, map_one, hres, map_one] + ext d x + simp [-valLinEquiv_apply] + map_mul' U₁ U₂ := by + have hres : ∀ f g : Module.End JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + rw [jetGaugeMatrix_mul, map_mul, hres, map_mul] + ext d x + simp + +/-- The entries of the gauge matrix of a jet of a constant gauge transformation are the +constant power series with the global gauge coefficients. -/ +lemma jetGaugeMatrix_ofConstant (g : GaugeGroupI) (p q : Fin 3 × Fin 2) : + jetGaugeMatrix (JetGaugeGroupI.ofConstant g) p q = + MvPowerSeries.C ((g.toU1.1 : ℂ) * (g.toSU3.1 p.1 q.1 * g.toSU2.1 p.2 q.2)) := by + rw [jetGaugeMatrix, Matrix.smul_apply, + show (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) = + MvPowerSeries.C ((g.toU1.1 : ℂ)) from rfl] + rw [Matrix.kroneckerMap_apply, + show (((JetGaugeGroupI.ofConstant g).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) p.1 q.1 = + MvPowerSeries.C (g.toSU3.1 p.1 q.1) from rfl, + show (((JetGaugeGroupI.ofConstant g).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) p.2 q.2 = + MvPowerSeries.C (g.toSU2.1 p.2 q.2) from rfl, + smul_eq_mul, ← map_mul, ← map_mul] + +/-- The identification of the jets of the quark doublet intertwines multiplication by a +scalar jet with the `JetRing`-scalar action on the colour–weak coordinates. -/ +lemma jetValLinEquiv_smul (χ : JetRing) (z : JetRing ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul JetRing + (EuclideanSpace JetRing (Fin 3 × Fin 2)) χ).restrictScalars ℂ) + (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, map_add] + | tmul f x => + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : QuarkDoublet) = 0 from rfl, TensorProduct.tmul_zero, + smul_zero, map_zero, map_zero] + | tmul vc w => + induction vc using TensorProduct.induction_on with + | zero => + rw [show ({ val := (0 : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) + ⊗ₜ[ℂ] w } : QuarkDoublet) = 0 from by + rw [TensorProduct.zero_tmul]; rfl, TensorProduct.tmul_zero, smul_zero, + map_zero, map_zero] + | tmul ψ c => + rw [TensorProduct.smul_tmul', smul_eq_mul, + show jetValLinEquiv ((χ * f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • (χ * f)) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) from rfl, + show Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((LinearMap.lsmul JetRing + (EuclideanSpace JetRing (Fin 3 × Fin 2)) χ).restrictScalars ℂ) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f)) + = ψ ⊗ₜ[ℂ] (χ • WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext q + show colourWeakEquiv (c ⊗ₜ[ℂ] w) q • (χ * f) + = χ * (colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) + rw [Algebra.mul_smul_comm] + | add a b ha hb => + rw [show ({ val := (a + b) ⊗ₜ[ℂ] w } : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ from by + rw [show (⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w + b ⊗ₜ[ℂ] w⟩ from rfl, TensorProduct.add_tmul], + TensorProduct.tmul_add, smul_add, map_add, ha, hb, map_add, map_add] + | add a b ha hb => + rw [show ({ val := a + b } : QuarkDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, smul_add, map_add, ha, hb, map_add, map_add] + +/-- **The jet gauge action on the jets of the quark doublet is fibrewise**: it commutes +with multiplication by scalar jets. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] QuarkDoublet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2)) := + LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2)) χ with hS + set M : Module.End JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2)) := + (Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U) : + Module.End JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2))) with hM + have hMS : M * S = S * M := LinearMap.ext fun e => by + simp only [Module.End.mul_apply, hS, LinearMap.lsmul_apply, map_smul] + apply jetValLinEquiv.injective + rw [show repJetGaugeGroupI U (χ • z) + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.LeftHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv (χ • z))) from rfl, + LinearEquiv.apply_symm_apply, jetValLinEquiv_smul, + show repJetGaugeGroupI U z + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.LeftHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv z)) from rfl, + jetValLinEquiv_smul, LinearEquiv.apply_symm_apply, ← Module.End.mul_apply, + ← Module.End.mul_apply, ← map_mul, ← map_mul, + show M.restrictScalars ℂ * S.restrictScalars ℂ = (M * S).restrictScalars ℂ from rfl, + show S.restrictScalars ℂ * M.restrictScalars ℂ = (S * M).restrictScalars ℂ from rfl, + hMS] + +/-- On jets of constant gauge transformations the jet action reduces to the global gauge +action on the fibre: the `(3, 2)_{1}` action on the quark-doublet factor, and the trivial +action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext d x + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => simp [show ({ val := 0 } : QuarkDoublet) = 0 from rfl] + | tmul vc w => + induction vc using TensorProduct.induction_on with + | zero => + have h : ({ val := (0 : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) + ⊗ₜ[ℂ] w } : QuarkDoublet) = 0 := by + rw [TensorProduct.zero_tmul] + rfl + rw [h] + simp + | tmul psi c => + apply jetValLinEquiv.injective + simp [repJetGaugeGroupI, jetValLinEquiv, repGaugeGroupI] + have halg : ∀ A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) JetRing, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End JetRing (EuclideanSpace JetRing (Fin 3 × Fin 2))) + = Matrix.toLpLin 2 2 A := fun _ => rfl + rw [TensorProduct.liftAux_tmul] + simp only [LinearMap.compl₂_apply, TensorProduct.mk_apply, LinearMap.smul_apply, + LinearMap.restrictScalars_apply, halg, Matrix.toLpLin_toLp] + rw [← TensorProduct.tmul_smul] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext p + simp only [WithLp.ofLp_smul, Pi.smul_apply, Matrix.toLin'_apply, + Matrix.mulVec_apply_eq_sum, jetGaugeMatrix_ofConstant, Algebra.smul_def, + MvPowerSeries.algebraMap_apply, Algebra.algebraMap_self_apply] + rw [Finset.sum_congr rfl fun q _ => by + rw [show MvPowerSeries.C ((g.toU1.1 : ℂ) * (g.toSU3.1 p.1 q.1 * g.toSU2.1 p.2 q.2)) + * (MvPowerSeries.C (c.ofLp q.1 * w.ofLp q.2) * d) + = MvPowerSeries.C ((g.toU1.1 : ℂ) * (g.toSU3.1 p.1 q.1 * g.toSU2.1 p.2 q.2) + * (c.ofLp q.1 * w.ofLp q.2)) * d from by + rw [← mul_assoc, ← map_mul]], ← Finset.sum_mul, ← map_sum] + rw [← mul_assoc, ← map_mul] + congr 1 + rw [Fintype.sum_prod_type, + show (∑ j, g.toSU3.1 p.1 j * c.ofLp j) * (∑ j, g.toSU2.1 p.2 j * w.ofLp j) + = ∑ i, ∑ j, (g.toSU3.1 p.1 i * c.ofLp i) * (g.toSU2.1 p.2 j * w.ofLp j) from + Finset.sum_mul_sum _ _ _ _, Finset.mul_sum] + congr 1 + refine Finset.sum_congr rfl fun i _ => ?_ + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun j _ => ?_ + ring + | add a b ha hb => + simp only [show ({ val := (a + b) ⊗ₜ[ℂ] w } : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ from by + rw [show (⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w + b ⊗ₜ[ℂ] w⟩ from rfl, TensorProduct.add_tmul], + map_add, ha, hb] + | add a b ha hb => + simp only [show ({ val := a + b } : QuarkDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + map_add, ha, hb] + end QuarkDoublet end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/GaugeAlgebraAction.lean new file mode 100644 index 000000000..83535f303 --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/QuarkDoublet/GaugeAlgebraAction.lean @@ -0,0 +1,768 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.LinearAlgebra.Matrix.Kronecker +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! +# The infinitesimal gauge action on the quark doublet + +## i. Overview + +The `(3, 2)_{1}` action of the gauge algebra on the quark doublet: the colour and weak +parts of the algebra element act on the combined colour–weak index through the Kronecker +sum, and the hypercharge part scales, all through the physicists' factor of `i`, matching +the group action `u • (U₃ ⊗ₖ U₂)` infinitesimally. The main theorem shows this is the +infinitesimal action underlying the jet gauge action `QuarkDoublet.repJetGaugeGroupI`, +in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`. + +## ii. Key results + +- `colourWeakEnd` : the endomorphism of the quark doublet defined by a colour–weak + matrix. +- `gaugeAlgebraAction` : the infinitesimal `(3, 2)_{1}` action of the gauge algebra. +- `jetGaugeMatrix_map_pderiv` : the derivative identity for the colour–weak matrix. +- `jetGaugeMatrix_mul_jetActionMatrix` : the equivariance identity for the colour–weak + matrix. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action. + +## iii. Table of contents + +- A. The action of the gauge algebra +- B. The colour–weak matrix of the jet gauge action +- C. The infinitesimal action underlies the jet gauge action + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +namespace QuarkDoublet + +open Matrix MatrixGroups Kronecker + +/-! + +## A. The action of the gauge algebra + +-/ + +/-- The identification of the quark doublet with a left-handed Weyl spinor tensored with + a colour–weak vector over the combined index `Fin 3 × Fin 2`: the `ℂ`-level analogue + of `jetValLinEquiv`. -/ +noncomputable def colourWeakValLinEquiv : + QuarkDoublet ≃ₗ[ℂ] Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3 × Fin 2) := + (valLinEquiv.trans (TensorProduct.assoc ℂ Fermion.LeftHandedWeyl + (EuclideanSpace ℂ (Fin 3)) (EuclideanSpace ℂ (Fin 2)))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.LeftHandedWeyl) + (colourWeakEquiv.trans (WithLp.linearEquiv 2 ℂ (Fin 3 × Fin 2 → ℂ)).symm) + +/-- The endomorphism of the quark doublet defined by a complex matrix over the + combined colour–weak index, with the Weyl factor untouched. -/ +noncomputable def colourWeakEnd (A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) : + QuarkDoublet →ₗ[ℂ] QuarkDoublet := + colourWeakValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3 × Fin 2)) Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) ∘ₗ colourWeakValLinEquiv.toLinearMap + +lemma colourWeakEnd_apply_mk (A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) + (v : QuarkDoublet) : + colourWeakEnd A v + = colourWeakValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) (colourWeakValLinEquiv v)) := rfl + +lemma colourWeakEnd_add (A B : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) : + colourWeakEnd (A + B) = colourWeakEnd A + colourWeakEnd B := by + rw [colourWeakEnd, colourWeakEnd, colourWeakEnd, map_add, map_add, + LinearMap.add_comp, LinearMap.comp_add] + +lemma colourWeakEnd_smul (z : ℂ) (A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) : + colourWeakEnd (z • A) = z • colourWeakEnd A := by + rw [colourWeakEnd, colourWeakEnd, map_smul, map_smul, LinearMap.smul_comp, + LinearMap.comp_smul] + +lemma colourWeakEnd_zero : colourWeakEnd 0 = 0 := by + rw [colourWeakEnd, map_zero, map_zero, LinearMap.zero_comp, LinearMap.comp_zero] + +lemma colourWeakEnd_neg (A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) : + colourWeakEnd (-A) = -colourWeakEnd A := by + rw [show (-A : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) = (-1 : ℂ) • A from by + rw [neg_one_smul], colourWeakEnd_smul, neg_one_smul] + +lemma colourWeakEnd_multiset_sum + (m : Multiset (Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ)) : + colourWeakEnd m.sum = (m.map colourWeakEnd).sum := by + induction m using Multiset.induction_on with + | empty => simp [colourWeakEnd_zero] + | cons A t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + colourWeakEnd_add, ih] + +/-- The colour–weak endomorphisms compose through matrix multiplication. -/ +lemma colourWeakEnd_mul (A B : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) : + colourWeakEnd (A * B) = colourWeakEnd A ∘ₗ colourWeakEnd B := by + refine LinearMap.ext fun v => ?_ + rw [colourWeakEnd_apply_mk, map_mul, map_mul, LinearMap.comp_apply, + colourWeakEnd_apply_mk, colourWeakEnd_apply_mk, LinearEquiv.apply_symm_apply] + rfl + +/-- The matrix of the infinitesimal `(3, 2)_{1}` action of a gauge algebra element on + the combined colour–weak index: `i` times the Kronecker sum of the colour and weak + parts, shifted by `i` times the hypercharge. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : + Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ := + Complex.I • (c.toSU3Matrix ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) ℂ) + + (1 : Matrix (Fin 3) (Fin 3) ℂ) ⊗ₖ c.toSU2Matrix + + c.toU1Value • 1) + +/-- **The infinitesimal action of the gauge algebra on the quark doublet**: the + derivative of the `(3, 2)_{1}` action of the gauge group, real-linear in the + algebra slot and complex-linear in the value slot — the form consumed by the + covariant derivative `IsGaugeField.covDerivIter` and by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] QuarkDoublet →ₗ[ℂ] QuarkDoublet where + toFun c := colourWeakEnd (actionMatrix c) + map_add' c₁ c₂ := by + rw [show actionMatrix (c₁ + c₂) = actionMatrix c₁ + actionMatrix c₂ from by + rw [actionMatrix, actionMatrix, actionMatrix, GaugeAlgebra.add_toSU3Matrix, + GaugeAlgebra.add_toSU2Matrix, GaugeAlgebra.add_toU1Value, + Matrix.add_kronecker, Matrix.kronecker_add] + module] + rw [colourWeakEnd_add] + map_smul' r c := by + rw [show actionMatrix (r • c) = (r : ℂ) • actionMatrix c from by + rw [actionMatrix, actionMatrix, GaugeAlgebra.smul_toSU3Matrix, + GaugeAlgebra.smul_toSU2Matrix, GaugeAlgebra.smul_toU1Value, + show (r • c.toSU3Matrix : Matrix (Fin 3) (Fin 3) ℂ) + = (r : ℂ) • c.toSU3Matrix from by + rw [← algebraMap_smul ℂ r c.toSU3Matrix]; rfl, + show (r • c.toSU2Matrix : Matrix (Fin 2) (Fin 2) ℂ) + = (r : ℂ) • c.toSU2Matrix from by + rw [← algebraMap_smul ℂ r c.toSU2Matrix]; rfl, + show r • c.toU1Value = (r : ℂ) • c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value]; rfl, + Matrix.smul_kronecker, Matrix.kronecker_smul] + module, + colourWeakEnd_smul] + refine LinearMap.ext fun v => ?_ + rw [RingHom.id_apply] + show (r : ℂ) • colourWeakEnd (actionMatrix c) v + = r • colourWeakEnd (actionMatrix c) v + rw [show ((r : ℝ) : ℂ) = algebraMap ℝ ℂ r from rfl, algebraMap_smul] + +/-! + +## B. The colour–weak matrix of the jet gauge action + +## C. The infinitesimal action underlies the jet gauge action + +The `(3, 2)_{1}` action of the gauge algebra is the infinitesimal action underlying the +jet gauge action, in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`: the base-point +Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law and +intertwine the action with the adjoint transports. The proofs work through the +colour–weak matrix `jetGaugeMatrix` of the jet action and the all-orders matrix Leibniz +rule at the base point. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : JetRing) : + pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) f) + = x.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, ih, JetRing.pderiv_comm] + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The jet-valued matrix of the infinitesimal `(3, 2)_{1}` action of a jet of gauge + algebra elements: the jet analogue of `actionMatrix`. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : + Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) JetRing := + Complex.I • (a.toSU3Matrix ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) JetRing) + + (1 : Matrix (Fin 3) (Fin 3) JetRing) ⊗ₖ a.toSU2Matrix + + a.toU1Value • 1) + +/-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ +lemma jetActionMatrix_map_cc_foldl (p : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + ((jetActionMatrix a).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := by + refine Matrix.ext fun i j => ?_ + rw [Matrix.map_apply, jetActionMatrix, actionMatrix, Matrix.smul_apply, + Matrix.smul_apply, Matrix.add_apply, Matrix.add_apply, Matrix.add_apply, + Matrix.add_apply, Matrix.kroneckerMap_apply, Matrix.kroneckerMap_apply, + Matrix.kroneckerMap_apply, Matrix.kroneckerMap_apply, Matrix.smul_apply, + Matrix.smul_apply, foldl_pderiv_smul, constantCoeff_smul, + JetRing.foldl_pderiv_add, JetRing.foldl_pderiv_add, map_add, map_add] + congr 1 + congr 1 + · congr 1 + · by_cases h3 : i.2 = j.2 + · rw [h3, Matrix.one_apply_eq, Matrix.one_apply_eq, mul_one, mul_one, + JetGaugeAlgebra.eval_iteratedDeriv_toSU3Matrix, Matrix.map_apply] + · rw [Matrix.one_apply_ne h3, Matrix.one_apply_ne h3, mul_zero, mul_zero, + JetRing.foldl_pderiv_zero, map_zero] + · by_cases h2 : i.1 = j.1 + · rw [h2, Matrix.one_apply_eq, Matrix.one_apply_eq, one_mul, one_mul, + JetGaugeAlgebra.eval_iteratedDeriv_toSU2Matrix, Matrix.map_apply] + · rw [Matrix.one_apply_ne h2, Matrix.one_apply_ne h2, zero_mul, zero_mul, + JetRing.foldl_pderiv_zero, map_zero] + · by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq, smul_eq_mul, mul_one, + smul_eq_mul, mul_one, JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + JetRing.foldl_pderiv_zero, map_zero] + +lemma repJetGaugeGroupI_eq_jetGaugeMatrix (U : JetGaugeGroupI) + (z : JetRing ⊗[ℂ] QuarkDoublet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ) + (jetValLinEquiv z)) := rfl + +/-- The entrywise formal derivative on the colour–weak coordinates, as a `ℂ`-linear + map. -/ +private noncomputable def pderivColourWeak (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace JetRing (Fin 3 × Fin 2) →ₗ[ℂ] + EuclideanSpace JetRing (Fin 3 × Fin 2) where + toFun v := WithLp.toLp 2 fun q => pderiv ℂ μ (v.ofLp q) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact Derivation.map_smul _ _ _ + +/-- The entrywise iterated formal derivative on the colour–weak coordinates. -/ +private noncomputable def foldColourWeak (x : Multiset (Fin 1 ⊕ Fin 3)) : + EuclideanSpace JetRing (Fin 3 × Fin 2) →ₗ[ℂ] + EuclideanSpace JetRing (Fin 3 × Fin 2) where + toFun v := WithLp.toLp 2 fun q => x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp q) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact JetRing.foldl_pderiv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact foldl_pderiv_smul x z _ + +/-- The entrywise base-point evaluation on the colour–weak coordinates. -/ +private noncomputable def ccColourWeak : + EuclideanSpace JetRing (Fin 3 × Fin 2) →ₗ[ℂ] EuclideanSpace ℂ (Fin 3 × Fin 2) where + toFun v := WithLp.toLp 2 fun q => constantCoeff (v.ofLp q) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext q + exact constantCoeff_smul _ _ + +private lemma pderivColourWeak_comp_foldColourWeak (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivColourWeak μ ∘ₗ foldColourWeak x = foldColourWeak (μ ::ₘ x) := by + refine LinearMap.ext fun v => ?_ + refine WithLp.ofLp_injective 2 ?_ + funext q + show pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp q)) + = (μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp q) + rw [Multiset.foldl_cons, pderiv_foldl] + +/-- The identification of quark-doublet jets intertwines the formal derivative with the + entrywise derivative on the colour–weak coordinates. -/ +private lemma jetValLinEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (z : JetRing ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (StandardModel.jetDeriv μ z) + = (TensorProduct.map LinearMap.id (pderivColourWeak μ)) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨v⟩ := d + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : QuarkDoublet) = 0 from rfl, TensorProduct.tmul_zero, + map_zero, map_zero, map_zero] + | tmul vc w => + induction vc using TensorProduct.induction_on with + | zero => + rw [show ({ val := (0 : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) + ⊗ₜ[ℂ] w } : QuarkDoublet) = 0 from by + rw [TensorProduct.zero_tmul]; rfl, TensorProduct.tmul_zero, map_zero, + map_zero, map_zero] + | tmul ψ c => + rw [show StandardModel.jetDeriv μ + (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = (pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet) from rfl, + show jetValLinEquiv + ((pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • pderiv ℂ μ f) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext q + exact (Derivation.map_smul (pderiv ℂ μ) + (colourWeakEquiv (c ⊗ₜ[ℂ] w) q) f).symm + | add a b ha hb => + rw [show ({ val := (a + b) ⊗ₜ[ℂ] w } : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ from by + rw [show (⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w + b ⊗ₜ[ℂ] w⟩ from rfl, TensorProduct.add_tmul], + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + | add a b ha hb => + rw [show ({ val := a + b } : QuarkDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + +/-- The identification of quark-doublet jets intertwines the iterated formal derivative + with the entrywise iterated derivative on the colour–weak coordinates. -/ +private lemma jetValLinEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) + (z : JetRing ⊗[ℂ] QuarkDoublet) : + jetValLinEquiv (StandardModel.jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColourWeak x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [StandardModel.jetIteratedDeriv_zero, LinearMap.id_apply, + show foldColourWeak 0 = LinearMap.id from LinearMap.ext fun v => + WithLp.ofLp_injective 2 rfl, + TensorProduct.map_id, LinearMap.id_apply] + | cons μ t ih => + rw [StandardModel.jetIteratedDeriv_cons, LinearMap.comp_apply, + jetValLinEquiv_jetDeriv, ih, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, pderivColourWeak_comp_foldColourWeak] + +/-- The base-point evaluation of a quark-doublet jet through the colour–weak + coordinates. -/ +private lemma colourWeakValLinEquiv_jetEval (z : JetRing ⊗[ℂ] QuarkDoublet) : + colourWeakValLinEquiv (StandardModel.jetEval z) + = (TensorProduct.map LinearMap.id ccColourWeak) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨v⟩ := d + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : QuarkDoublet) = 0 from rfl, TensorProduct.tmul_zero] + simp + | tmul vc w => + induction vc using TensorProduct.induction_on with + | zero => + rw [show ({ val := (0 : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) + ⊗ₜ[ℂ] w } : QuarkDoublet) = 0 from by + rw [TensorProduct.zero_tmul]; rfl, TensorProduct.tmul_zero] + simp + | tmul ψ c => + rw [StandardModel.jetEval_tmul, map_smul, + show colourWeakValLinEquiv (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c ⊗ₜ[ℂ] w⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply, ← TensorProduct.tmul_smul] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext q + show constantCoeff f • colourWeakEquiv (c ⊗ₜ[ℂ] w) q + = constantCoeff (colourWeakEquiv (c ⊗ₜ[ℂ] w) q • f) + simp [constantCoeff_smul, mul_comm] + | add a b ha hb => + rw [show ({ val := (a + b) ⊗ₜ[ℂ] w } : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ from by + rw [show (⟨a ⊗ₜ[ℂ] w⟩ + ⟨b ⊗ₜ[ℂ] w⟩ : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] w + b ⊗ₜ[ℂ] w⟩ from rfl, TensorProduct.add_tmul], + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + | add a b ha hb => + rw [show ({ val := a + b } : QuarkDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + +set_option maxHeartbeats 1000000 in +/-- **The derivative identity** for the colour–weak matrix of the jet gauge action: the + formal derivative of the colour–weak matrix is minus the jet action matrix of the + Maurer–Cartan form times the colour–weak matrix. -/ +lemma jetGaugeMatrix_map_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (jetGaugeMatrix U).map (fun f => pderiv ℂ μ f) + = -(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U) := by + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + have hm₃U₃ : (maurerCartanForm U μ).toSU3Matrix * U.1.1 + = Complex.I • U.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU3Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₃u, + Matrix.mul_one] + have hm₂U₂ : (maurerCartanForm U μ).toSU2Matrix * U.2.1.1 + = Complex.I • U.2.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU2Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₂u, + Matrix.mul_one] + have hmap : (jetGaugeMatrix U).map (fun f => pderiv ℂ μ f) + = (pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing)) • + (((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)) + + ((U.2.2 : unitary JetRing) : JetRing) • + ((((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)).map fun f => pderiv ℂ μ f) := by + refine Matrix.ext fun i j => ?_ + simp only [jetGaugeMatrix, Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, + smul_eq_mul] + exact hleib _ _ + have hkron : ((((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) ⊗ₖ + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)).map fun f => pderiv ℂ μ f) + = (U.1.1.map (pderiv ℂ μ)) ⊗ₖ U.2.1.1 + + U.1.1 ⊗ₖ (U.2.1.1.map (pderiv ℂ μ)) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.kroneckerMap_apply, Matrix.add_apply] + exact hleib _ _ + rw [hmap, hkron, jetActionMatrix, jetGaugeMatrix, Matrix.mul_smul, Matrix.smul_mul, + Matrix.add_mul, Matrix.add_mul, ← Matrix.mul_kronecker_mul, + ← Matrix.mul_kronecker_mul, + Matrix.one_mul, Matrix.one_mul, hm₃U₃, hm₂U₂, Matrix.smul_mul, Matrix.one_mul, + Matrix.smul_kronecker, Matrix.kronecker_smul, maurerCartanForm_toU1Value, + smul_assoc, ← smul_add, ← smul_add, smul_smul Complex.I Complex.I, Complex.I_mul_I, + neg_one_smul, smul_neg, neg_neg] + conv_rhs => rw [smul_add, smul_smul] + rw [show ((U.2.2 : unitary JetRing) : JetRing) + * (pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing)) + = pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) from by + linear_combination pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) * huu] + exact add_comm _ _ + +/-- **The equivariance identity** for the colour–weak matrix of the jet gauge action: + the colour–weak matrix intertwines the constant jet action matrix with its adjoint + transform. -/ +lemma jetGaugeMatrix_mul_jetActionMatrix (U : JetGaugeGroupI) (c : GaugeAlgebra) : + jetGaugeMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = jetActionMatrix (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c)) + * jetGaugeMatrix U := by + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rw [jetGaugeMatrix, jetActionMatrix, jetActionMatrix, + JetGaugeAlgebra.adjointMap_toSU3Matrix, JetGaugeAlgebra.adjointMap_toSU2Matrix, + JetGaugeAlgebra.adjointMap_toU1Value] + conv_lhs => rw [Matrix.smul_mul, Matrix.mul_smul, Matrix.mul_add, Matrix.mul_add, + ← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul, Matrix.mul_one, + Matrix.mul_one, Matrix.mul_smul, Matrix.mul_one] + conv_rhs => rw [Matrix.mul_smul, Matrix.smul_mul, Matrix.add_mul, Matrix.add_mul, + ← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul, Matrix.one_mul, + Matrix.one_mul, Matrix.smul_mul, Matrix.one_mul, Matrix.mul_assoc, hU₃u, + Matrix.mul_one, Matrix.mul_assoc, hU₂u, Matrix.mul_one] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +set_option maxHeartbeats 1000000 in +/-- **The base-point Taylor coefficients of the jet gauge action** on the quark + doublet are the colour–weak endomorphisms of the base-point Taylor coefficients of + the colour–weak matrix. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = colourWeakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + refine LinearMap.ext fun d => ?_ + apply colourWeakValLinEquiv.injective + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x d + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant d))) from rfl, + colourWeakValLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourWeakEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_jetGaugeMatrix, LinearEquiv.apply_symm_apply, + StandardModel.jetOfConstant_apply] + obtain ⟨v⟩ := d + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : QuarkDoublet) = 0 from rfl, TensorProduct.tmul_zero] + simp + | add a b ha hb => + rw [show ({ val := a + b } : QuarkDoublet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + | tmul vc wk => + induction vc using TensorProduct.induction_on with + | zero => + rw [show ({ val := (0 : Fermion.LeftHandedWeyl ⊗[ℂ] EuclideanSpace ℂ (Fin 3)) + ⊗ₜ[ℂ] wk } : QuarkDoublet) = 0 from by + rw [TensorProduct.zero_tmul]; rfl, TensorProduct.tmul_zero] + simp + | tmul ψ cv => + rw [show jetValLinEquiv + ((1 : JetRing) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] cv ⊗ₜ[ℂ] wk⟩ : QuarkDoublet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : JetRing)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : JetRing))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : JetRing))) from rfl, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, + show colourWeakValLinEquiv (⟨ψ ⊗ₜ[ℂ] cv ⊗ₜ[ℂ] wk⟩ : QuarkDoublet) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3 × Fin 2)) + Fermion.LeftHandedWeyl + (Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)))) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun q => colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : JetRing))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + (WithLp.toLp 2 fun q => colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun q => + colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q • (1 : JetRing))).ofLp j + = ∑ k, jetGaugeMatrix U j k * + (colourWeakEquiv (cv ⊗ₜ[ℂ] wk) k • (1 : JetRing)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + (WithLp.toLp 2 fun q => colourWeakEquiv (cv ⊗ₜ[ℂ] wk) q)).ofLp j + = ∑ k, constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (jetGaugeMatrix U j k)) * colourWeakEquiv (cv ⊗ₜ[ℂ] wk) k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + JetRing.foldl_pderiv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + mul_comm] + | add a b ha hb => + rw [show ({ val := (a + b) ⊗ₜ[ℂ] wk } : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] wk⟩ + ⟨b ⊗ₜ[ℂ] wk⟩ from by + rw [show (⟨a ⊗ₜ[ℂ] wk⟩ + ⟨b ⊗ₜ[ℂ] wk⟩ : QuarkDoublet) + = ⟨a ⊗ₜ[ℂ] wk + b ⊗ₜ[ℂ] wk⟩ from rfl, TensorProduct.add_tmul], + TensorProduct.tmul_add] + simp only [map_add] + rw [ha, hb] + + +/-- The colour–weak endomorphism of the identity matrix is the identity. -/ +lemma colourWeakEnd_one : colourWeakEnd 1 = LinearMap.id := by + refine LinearMap.ext fun v => ?_ + rw [colourWeakEnd_apply_mk, map_one, map_one, Module.End.one_apply, + LinearEquiv.symm_apply_apply, LinearMap.id_apply] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have h2 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((jetGaugeMatrix U).map fun f => + constantCoeff ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = 1 := by + rw [show (1 : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) + = (1 : Matrix (Fin 3) (Fin 3) ℂ) ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) ℂ) from + (Matrix.one_kronecker_one).symm, ← h1, ← h2] + ext i j + rw [Matrix.map_apply, Multiset.foldl_zero, jetGaugeMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, hu, one_mul, Matrix.kronecker_apply, + Matrix.kronecker_apply, map_mul, RingHom.mapMatrix_apply, + RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.map_apply] + rw [repCoeff_eq, hM, colourWeakEnd_one] + +set_option maxHeartbeats 1000000 in +/-- **The `(3, 2)_{1}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the quark doublet**: its base-point Taylor + coefficients obey the Maurer–Cartan Leibniz law and intertwine the action with the + adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : ((jetGaugeMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum) := by + rw [show ((jetGaugeMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (((jetGaugeMatrix U).map fun f => pderiv ℂ μ f).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + Multiset.foldl_cons], + jetGaugeMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, foldl_pderiv_neg, map_neg], + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [jetActionMatrix_map_cc_foldl])) + rw [repCoeff_eq, hMcons, colourWeakEnd_neg, colourWeakEnd_multiset_sum, + Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, colourWeakEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hCsmul : ∀ z w : ℂ, (z • (C w : JetRing)) = C (z * w) := fun z w => by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + Algebra.algebraMap_self_apply, ← map_mul] + have hconst : jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = (actionMatrix c).map (C : ℂ → JetRing) := by + have hone : ∀ {n : Type} [DecidableEq n] (a b : n), + (1 : Matrix n n JetRing) a b = C ((1 : Matrix n n ℂ) a b) := by + intro n _ a b + by_cases h : a = b + · subst h; rw [Matrix.one_apply_eq, Matrix.one_apply_eq, map_one] + · rw [Matrix.one_apply_ne h, Matrix.one_apply_ne h, map_zero] + refine Matrix.ext fun i j => ?_ + rw [jetActionMatrix, actionMatrix, Matrix.map_apply, Matrix.smul_apply, + Matrix.smul_apply, Matrix.add_apply, Matrix.add_apply, Matrix.add_apply, + Matrix.add_apply, Matrix.kroneckerMap_apply, Matrix.kroneckerMap_apply, + Matrix.kroneckerMap_apply, Matrix.kroneckerMap_apply, Matrix.smul_apply, + Matrix.smul_apply, JetGaugeAlgebra.ofConstant_toSU3Matrix, + JetGaugeAlgebra.ofConstant_toSU2Matrix, JetGaugeAlgebra.ofConstant_toU1Value, + Matrix.map_apply, Matrix.map_apply, hone i.2 j.2, hone i.1 j.1, hone i j, + ← map_mul, ← map_mul, + show (C c.toU1Value : JetRing) + • C ((1 : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) i j) + = C (c.toU1Value • (1 : Matrix (Fin 3 × Fin 2) (Fin 3 × Fin 2) ℂ) i j) + from by rw [smul_eq_mul, smul_eq_mul, ← map_mul], + ← map_add, ← map_add, hCsmul, smul_eq_mul, smul_eq_mul] + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((actionMatrix c).map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then actionMatrix c else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, constantCoeff_C] + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (IsGaugeField.adjointCoeff U p.1 c) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have h1 : ((jetGaugeMatrix U + * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c := by + rw [hconst, matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((jetGaugeMatrix U).map fun f => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p hp => by rw [if_neg hp, Matrix.mul_zero]), + if_pos rfl] + rw [← h1, jetGaugeMatrix_mul_jetActionMatrix, + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [jetActionMatrix_map_cc_foldl, + show JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c))) + = IsGaugeField.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourWeakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + ∘ₗ gaugeAlgebraAction c + = colourWeakEnd (((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c) from by + rw [colourWeakEnd_mul]; rfl, + hMact, colourWeakEnd_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, colourWeakEnd_mul, repCoeff_eq] + rfl + +end InfinitesimalAction + +end QuarkDoublet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean b/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean index 8fe9c0071..350abbd87 100644 --- a/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean +++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet.lean @@ -6,7 +6,12 @@ Authors: Joseph Tooby-Smith module public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps /-! # Up-type singlets @@ -77,6 +82,21 @@ lemma val_smul (r : ℂ) (q : UpSinglet) : (r • q).val = r • q.val := rfl /-! +## The basis of the up-singlet space + +-/ + +/-- A basis on the up singlets. -/ +noncomputable def basis : Module.Basis (Fin 2 × Fin 3) ℂ UpSinglet := + (Fermion.RightHandedWeyl.basis.tensorProduct + (EuclideanSpace.basisFun (Fin 3) ℂ).toBasis).map valLinEquiv.symm + +instance : Module.Finite ℂ UpSinglet := Module.Finite.of_basis basis + +instance : Module.Free ℂ UpSinglet := Module.Free.of_basis basis + +/-! + ## Lorentz group representation -/ @@ -206,6 +226,189 @@ noncomputable def repGaugeGroup : (Q : GaugeGroupQuot) → | .ℤ₂ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₂) | .ℤ₃ => QuotientGroup.lift _ repGaugeGroupI (gaugeGroup_subgroup_le_ker_repGaugeGroupI .ℤ₃) +/-! + +## The representation of the jet gauge group + +-/ + +/-- Absorbs the jet ring into the colour index: a jet of an up-type singlet is the +same thing as a right-handed Weyl spinor tensored with a `JetRing`-valued colour +vector, + + `JetRing ⊗[ℂ] UpSinglet ≃ RightHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3)`. + +-/ +noncomputable def jetValLinEquiv : + JetRing ⊗[ℂ] UpSinglet ≃ₗ[ℂ] + Fermion.RightHandedWeyl ⊗[ℂ] EuclideanSpace JetRing (Fin 3) := + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) valLinEquiv).trans <| + (TensorProduct.leftComm ℂ JetRing Fermion.RightHandedWeyl + (EuclideanSpace ℂ (Fin 3))).trans <| + TensorProduct.congr (LinearEquiv.refl ℂ Fermion.RightHandedWeyl) <| + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) + (WithLp.linearEquiv 2 ℂ (Fin 3 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ JetRing JetRing (Fin 3)).trans + (WithLp.linearEquiv 2 JetRing (Fin 3 → JetRing)).symm).restrictScalars ℂ + +open Matrix in +/-- The `(3, 1)_{4}` action of the jet gauge group on the jet space of the up-type +singlet. Through `jetValLinEquiv` the colour matrix of the gauge jet, carrying the +`4` hypercharge phase `u ^ 4`, acts `JetRing`-linearly on the colour factor by +matrix-vector multiplication, while the Weyl factor is untouched. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] UpSinglet) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 + ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing))).restrictScalars ℂ) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End JetRing (EuclideanSpace JetRing (Fin 3))).restrictScalars ℂ + = 1 := rfl + rw [show ((((1 : JetGaugeGroupI).2.2 : unitary JetRing) : JetRing) ^ 4 • + (((1 : JetGaugeGroupI).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) = 1 from by simp, + map_one, hres, map_one] + ext d x + simp [-valLinEquiv_apply] + map_mul' U₁ U₂ := by + have hres : ∀ f g : Module.End JetRing (EuclideanSpace JetRing (Fin 3)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + have hM : ((((U₁ * U₂).2.2 : unitary JetRing) : JetRing) ^ 4 • + (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) = + (((U₁.2.2 : unitary JetRing) : JetRing) ^ 4 • + ((U₁.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) * + (((U₂.2.2 : unitary JetRing) : JetRing) ^ 4 • + ((U₂.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) := by + rw [show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) + from rfl, + show (((U₁ * U₂).1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing) = + ((U₁.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) * + ((U₂.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + from rfl, + mul_pow, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + rw [hM, map_mul, hres, map_mul] + ext d x + simp + +/-- The identification of the jets of the up-type singlet intertwines multiplication by +a scalar jet with the `JetRing`-scalar action on the colour coordinates. -/ +lemma jetValLinEquiv_smul (χ : JetRing) (z : JetRing ⊗[ℂ] UpSinglet) : + jetValLinEquiv (χ • z) + = Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ).restrictScalars ℂ) + (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, map_add] + | tmul f x => + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : UpSinglet) = 0 from rfl, TensorProduct.tmul_zero, + smul_zero, map_zero, map_zero] + | tmul ψ c => + rw [TensorProduct.smul_tmul', smul_eq_mul, + show jetValLinEquiv ((χ * f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (χ * f)) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + show Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ).restrictScalars ℂ) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f)) + = ψ ⊗ₜ[ℂ] (χ • WithLp.toLp 2 fun i => c.ofLp i • f) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show c.ofLp i • (χ * f) = χ * (c.ofLp i • f) + rw [Algebra.mul_smul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : UpSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, smul_add, map_add, ha, hb, map_add, map_add] + +/-- **The jet gauge action on the jets of the up-type singlet is fibrewise**: it commutes +with multiplication by scalar jets. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] UpSinglet) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + set S : Module.End JetRing (EuclideanSpace JetRing (Fin 3)) := + LinearMap.lsmul JetRing (EuclideanSpace JetRing (Fin 3)) χ with hS + set M : Module.End JetRing (EuclideanSpace JetRing (Fin 3)) := + (Matrix.toLpLinAlgEquiv 2 + ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)) : + Module.End JetRing (EuclideanSpace JetRing (Fin 3))) with hM + have hMS : M * S = S * M := LinearMap.ext fun e => by + simp only [Module.End.mul_apply, hS, LinearMap.lsmul_apply, map_smul] + apply jetValLinEquiv.injective + rw [show repJetGaugeGroupI U (χ • z) + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.RightHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv (χ • z))) from rfl, + LinearEquiv.apply_symm_apply, jetValLinEquiv_smul, + show repJetGaugeGroupI U z + = jetValLinEquiv.symm (Module.End.lTensorAlgHom ℂ _ Fermion.RightHandedWeyl + (M.restrictScalars ℂ) (jetValLinEquiv z)) from rfl, + jetValLinEquiv_smul, LinearEquiv.apply_symm_apply, ← Module.End.mul_apply, + ← Module.End.mul_apply, ← map_mul, ← map_mul, + show M.restrictScalars ℂ * S.restrictScalars ℂ = (M * S).restrictScalars ℂ from rfl, + show S.restrictScalars ℂ * M.restrictScalars ℂ = (S * M).restrictScalars ℂ from rfl, + hMS] + +/-- On jets of constant gauge transformations the jet action reduces to the global +gauge action on the fibre: the `(3, 1)_{4}` action on the up-singlet factor, and the +trivial action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext d x + obtain ⟨v⟩ := x + induction v using TensorProduct.induction_on with + | zero => simp [show ({ val := 0 } : UpSinglet) = 0 from rfl] + | tmul psi c => + apply jetValLinEquiv.injective + simp [repJetGaugeGroupI, jetValLinEquiv, repGaugeGroupI] + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).1 : + specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) i j + = MvPowerSeries.C (g.toSU3.1 i j) := fun _ _ => rfl + have halg : ∀ A : Matrix (Fin 3) (Fin 3) JetRing, + (Matrix.toLpLinAlgEquiv 2 A : + Module.End JetRing (EuclideanSpace JetRing (Fin 3))) + = Matrix.toLpLin 2 2 A := fun _ => rfl + have hvec : ∀ i : Fin 3, + (∑ x, MvPowerSeries.C ((g.toSU3.1) i x) * (MvPowerSeries.C (c.ofLp x) * d)) + = MvPowerSeries.C (∑ x, (g.toSU3.1) i x * c.ofLp x) * d := by + intro i + rw [map_sum, Finset.sum_mul] + exact Finset.sum_congr rfl fun x _ => by rw [← mul_assoc, ← map_mul] + rw [TensorProduct.liftAux_tmul, ← TensorProduct.tmul_smul] + simp only [LinearMap.compl₂_apply, TensorProduct.mk_apply, LinearMap.smul_apply, + LinearMap.restrictScalars_apply, halg, Matrix.toLpLin_toLp] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + simp only [WithLp.ofLp_smul, Pi.smul_apply, Matrix.toLin'_apply, + Matrix.mulVec_apply_eq_sum, hM, Algebra.smul_def, MvPowerSeries.algebraMap_apply, + hu, map_pow, Algebra.algebraMap_self_apply] + rw [hvec i] + | add a b ha hb => + simp only [show ({ val := a + b } : UpSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + map_add, ha, hb] + end UpSinglet end StandardModel diff --git a/Physlib/Particles/StandardModel/Fermions/UpSinglet/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/Fermions/UpSinglet/GaugeAlgebraAction.lean new file mode 100644 index 000000000..b8d2c1a3a --- /dev/null +++ b/Physlib/Particles/StandardModel/Fermions/UpSinglet/GaugeAlgebraAction.lean @@ -0,0 +1,630 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.UpSinglet +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! +# The infinitesimal gauge action on the up-type singlet + +## i. Overview + +The `(3, 1)_{4}` action of the gauge algebra on the up-type singlet: the colour part of +the algebra element acts on the colour index and the hypercharge part scales, both +through the physicists' factor of `i`, matching the group action `u ^ 4 • U₃` +infinitesimally. The main theorem shows this is the infinitesimal action underlying the +jet gauge action `UpSinglet.repJetGaugeGroupI`, in the sense of +`GaugeAlgebra.IsInfinitesimalActionOf`. + +## ii. Key results + +- `colourEnd` : the endomorphism of the up singlet defined by a colour matrix. +- `gaugeAlgebraAction` : the infinitesimal `(3, 1)_{4}` action of the gauge algebra. +- `upMatrix` : the `JetRing`-valued colour matrix of the jet gauge action. +- `upMatrix_map_pderiv` : the derivative identity for the colour matrix. +- `upMatrix_mul_jetActionMatrix` : the equivariance identity for the colour matrix. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action. + +## iii. Table of contents + +- A. The action of the gauge algebra +- B. The colour matrix of the jet gauge action +- C. The infinitesimal action underlies the jet gauge action + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +namespace UpSinglet + +open Matrix MatrixGroups + +/-! + +## A. The action of the gauge algebra + +-/ + +/-- The endomorphism of the up singlet defined by a `3 × 3` complex matrix acting on + the colour index, with the Weyl factor untouched. -/ +noncomputable def colourEnd (A : Matrix (Fin 3) (Fin 3) ℂ) : + UpSinglet →ₗ[ℂ] UpSinglet := + valLinEquiv.symm.toLinearMap ∘ₗ + Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) ∘ₗ valLinEquiv.toLinearMap + +lemma colourEnd_apply_mk (A : Matrix (Fin 3) (Fin 3) ℂ) (v : UpSinglet) : + colourEnd A v + = valLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 A) (valLinEquiv v)) := rfl + +lemma colourEnd_add (A B : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (A + B) = colourEnd A + colourEnd B := by + rw [colourEnd, colourEnd, colourEnd, map_add, map_add, LinearMap.add_comp, + LinearMap.comp_add] + +lemma colourEnd_smul (z : ℂ) (A : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (z • A) = z • colourEnd A := by + rw [colourEnd, colourEnd, map_smul, map_smul, LinearMap.smul_comp, + LinearMap.comp_smul] + +lemma colourEnd_zero : colourEnd 0 = 0 := by + rw [colourEnd, map_zero, map_zero, LinearMap.zero_comp, LinearMap.comp_zero] + +lemma colourEnd_neg (A : Matrix (Fin 3) (Fin 3) ℂ) : colourEnd (-A) = -colourEnd A := by + rw [show (-A : Matrix (Fin 3) (Fin 3) ℂ) = (-1 : ℂ) • A from by rw [neg_one_smul], + colourEnd_smul, neg_one_smul] + +lemma colourEnd_multiset_sum (m : Multiset (Matrix (Fin 3) (Fin 3) ℂ)) : + colourEnd m.sum = (m.map colourEnd).sum := by + induction m using Multiset.induction_on with + | empty => simp [colourEnd_zero] + | cons A t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + colourEnd_add, ih] + +/-- The colour endomorphisms compose through matrix multiplication. -/ +lemma colourEnd_mul (A B : Matrix (Fin 3) (Fin 3) ℂ) : + colourEnd (A * B) = colourEnd A ∘ₗ colourEnd B := by + refine LinearMap.ext fun v => ?_ + rw [colourEnd_apply_mk, map_mul, map_mul, LinearMap.comp_apply, colourEnd_apply_mk, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply] + rfl + +/-- The matrix of the infinitesimal `(3, 1)_{4}` action of a gauge algebra element on + the colour index: `i` times the colour part, shifted by `i` times `4` the + hypercharge. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : Matrix (Fin 3) (Fin 3) ℂ := + Complex.I • (c.toSU3Matrix + ((4 : ℂ) • c.toU1Value) • 1) + +/-- **The infinitesimal action of the gauge algebra on the up-type singlet**: the + derivative of the `(3, 1)_{4}` action of the gauge group, real-linear in the + algebra slot and complex-linear in the value slot — the form consumed by the + covariant derivative `IsGaugeField.covDerivIter` and by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] UpSinglet →ₗ[ℂ] UpSinglet where + toFun c := colourEnd (actionMatrix c) + map_add' c₁ c₂ := by + rw [show actionMatrix (c₁ + c₂) = actionMatrix c₁ + actionMatrix c₂ from by + rw [actionMatrix, actionMatrix, actionMatrix, GaugeAlgebra.add_toSU3Matrix, + GaugeAlgebra.add_toU1Value] + module] + rw [colourEnd_add] + map_smul' r c := by + rw [show actionMatrix (r • c) = (r : ℂ) • actionMatrix c from by + rw [actionMatrix, actionMatrix, GaugeAlgebra.smul_toSU3Matrix, + GaugeAlgebra.smul_toU1Value, + show (r • c.toSU3Matrix : Matrix (Fin 3) (Fin 3) ℂ) + = (r : ℂ) • c.toSU3Matrix from by + rw [← algebraMap_smul ℂ r c.toSU3Matrix]; rfl, + show r • c.toU1Value = (r : ℂ) • c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value]; rfl] + module, + colourEnd_smul] + refine LinearMap.ext fun v => ?_ + rw [RingHom.id_apply] + show (r : ℂ) • colourEnd (actionMatrix c) v = r • colourEnd (actionMatrix c) v + rw [show ((r : ℝ) : ℂ) = algebraMap ℝ ℂ r from rfl, algebraMap_smul] + +/-! + +## B. The colour matrix of the jet gauge action + +## C. The infinitesimal action underlies the jet gauge action + +The `(3, 1)_{4}` action of the gauge algebra is the infinitesimal action underlying the +jet gauge action, in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`: the base-point +Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law and +intertwine the action with the adjoint transports. The proofs work through the colour +matrix of the jet action and the all-orders matrix Leibniz rule at the base point. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : JetRing) : + pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) f) + = x.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, ih, JetRing.pderiv_comm] + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The jet-valued matrix of the infinitesimal `(3, 1)_{4}` action of a jet of gauge + algebra elements: the jet analogue of `actionMatrix`. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : Matrix (Fin 3) (Fin 3) JetRing := + Complex.I • (a.toSU3Matrix + ((4 : ℂ) • a.toU1Value) • 1) + +/-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ +lemma jetActionMatrix_map_cc_foldl (p : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + ((jetActionMatrix a).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := by + ext i j + rw [Matrix.map_apply, jetActionMatrix, actionMatrix, Matrix.smul_apply, + Matrix.add_apply, Matrix.smul_apply, Matrix.smul_apply, Matrix.add_apply, + Matrix.smul_apply, foldl_pderiv_smul, constantCoeff_smul, JetRing.foldl_pderiv_add, + map_add, JetGaugeAlgebra.eval_iteratedDeriv_toSU3Matrix, Matrix.map_apply] + congr 2 + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq, smul_eq_mul, mul_one, smul_eq_mul, + mul_one, foldl_pderiv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + JetRing.foldl_pderiv_zero, map_zero] + +/-- The `JetRing`-valued colour matrix of the jet gauge action on the up singlet: the + colour matrix of the gauge jet carrying the `4` hypercharge phase. -/ +noncomputable def upMatrix (U : JetGaugeGroupI) : Matrix (Fin 3) (Fin 3) JetRing := + (((U.2.2 : unitary JetRing) : JetRing)) ^ 4 • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + +lemma repJetGaugeGroupI_eq_upMatrix (U : JetGaugeGroupI) + (z : JetRing ⊗[ℂ] UpSinglet) : + repJetGaugeGroupI U z + = jetValLinEquiv.symm + (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)).restrictScalars ℂ) + (jetValLinEquiv z)) := rfl + +/-- The entrywise formal derivative on the colour coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivColour (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace JetRing (Fin 3) where + toFun v := WithLp.toLp 2 fun i => pderiv ℂ μ (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact Derivation.map_smul _ _ _ + +/-- The entrywise iterated formal derivative on the colour coordinates. -/ +private noncomputable def foldColour (x : Multiset (Fin 1 ⊕ Fin 3)) : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace JetRing (Fin 3) where + toFun v := WithLp.toLp 2 fun i => x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact JetRing.foldl_pderiv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact foldl_pderiv_smul x z _ + +/-- The entrywise base-point evaluation on the colour coordinates. -/ +private noncomputable def ccColour : + EuclideanSpace JetRing (Fin 3) →ₗ[ℂ] EuclideanSpace ℂ (Fin 3) where + toFun v := WithLp.toLp 2 fun i => constantCoeff (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact constantCoeff_smul _ _ + +private lemma pderivColour_comp_foldColour (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivColour μ ∘ₗ foldColour x = foldColour (μ ::ₘ x) := by + refine LinearMap.ext fun v => ?_ + refine WithLp.ofLp_injective 2 ?_ + funext i + show pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i)) + = (μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + rw [Multiset.foldl_cons, pderiv_foldl] + +/-- The identification of up-singlet jets intertwines the formal derivative with the + entrywise derivative on the colour coordinates. -/ +private lemma jetValLinEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (z : JetRing ⊗[ℂ] UpSinglet) : + jetValLinEquiv (StandardModel.jetDeriv μ z) + = (TensorProduct.map LinearMap.id (pderivColour μ)) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : UpSinglet) = 0 from rfl, TensorProduct.tmul_zero, + map_zero, map_zero, map_zero] + | tmul ψ c => + rw [show StandardModel.jetDeriv μ (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = (pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet) from rfl, + show jetValLinEquiv ((pderiv ℂ μ f) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • pderiv ℂ μ f) from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + exact (Derivation.map_smul (pderiv ℂ μ) (c.ofLp i) f).symm + | add a b ha hb => + rw [show ({ val := a + b } : UpSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +/-- The identification of up-singlet jets intertwines the iterated formal derivative + with the entrywise iterated derivative on the colour coordinates. -/ +private lemma jetValLinEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) + (z : JetRing ⊗[ℂ] UpSinglet) : + jetValLinEquiv (StandardModel.jetIteratedDeriv x z) + = (TensorProduct.map LinearMap.id (foldColour x)) (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [StandardModel.jetIteratedDeriv_zero, LinearMap.id_apply, + show foldColour 0 = LinearMap.id from LinearMap.ext fun v => + WithLp.ofLp_injective 2 rfl, + TensorProduct.map_id, LinearMap.id_apply] + | cons μ t ih => + rw [StandardModel.jetIteratedDeriv_cons, LinearMap.comp_apply, + jetValLinEquiv_jetDeriv, ih, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, pderivColour_comp_foldColour] + +/-- The base-point evaluation of an up-singlet jet through the colour coordinates. -/ +private lemma valLinEquiv_jetEval (z : JetRing ⊗[ℂ] UpSinglet) : + valLinEquiv (StandardModel.jetEval z) + = (TensorProduct.map LinearMap.id ccColour) (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp; rfl + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f d => + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : UpSinglet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rfl + | tmul ψ c => + rw [StandardModel.jetEval_tmul, map_smul, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet) = ψ ⊗ₜ[ℂ] c from rfl, + show jetValLinEquiv (f ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • f) from rfl, + TensorProduct.map_tmul, LinearMap.id_apply, ← TensorProduct.tmul_smul] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext i + show (constantCoeff f • c).ofLp i = constantCoeff (c.ofLp i • f) + simp [constantCoeff_smul, mul_comm] + | add a b ha hb => + rw [show ({ val := a + b } : UpSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, ha, hb, map_add, map_add] + +set_option maxHeartbeats 1000000 in +/-- **The derivative identity** for the colour matrix of the jet gauge action: the + formal derivative of the colour matrix is minus the jet action matrix of the + Maurer–Cartan form times the colour matrix. -/ +lemma upMatrix_map_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (upMatrix U).map (fun f => pderiv ℂ μ f) + = -(jetActionMatrix (maurerCartanForm U μ) * upMatrix U) := by + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + have hpow : pderiv ℂ μ (((U.2.2 : unitary JetRing) : JetRing) ^ 4) + = 4 * ((U.2.2 : unitary JetRing) : JetRing) ^ 3 + * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) := by + rw [show ((U.2.2 : unitary JetRing) : JetRing) ^ 4 + = ((U.2.2 : unitary JetRing) : JetRing) + * (((U.2.2 : unitary JetRing) : JetRing) + * (((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing))) from by ring, + hleib, hleib, hleib] + ring + have hm₃U₃ : (maurerCartanForm U μ).toSU3Matrix * U.1.1 + = Complex.I • U.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU3Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₃u, + Matrix.mul_one] + have hiC : (algebraMap ℂ JetRing) Complex.I * (algebraMap ℂ JetRing) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : (((((U.2.2 : unitary JetRing) : JetRing)) ^ 4) • + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : + Matrix (Fin 3) (Fin 3) JetRing)).map (fun f => pderiv ℂ μ f) + = (pderiv ℂ μ ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4)) • U.1.1 + + ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4) + • (U.1.1.map (pderiv ℂ μ)) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul] + exact hleib _ _ + rw [upMatrix, jetActionMatrix, hmap, Matrix.smul_mul, Matrix.add_mul, + Matrix.mul_smul, hm₃U₃, Matrix.smul_mul, Matrix.one_mul, + smul_comm ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4) Complex.I, + smul_add, smul_smul Complex.I Complex.I, Complex.I_mul_I, neg_one_smul, + ← smul_assoc, neg_add_rev, neg_neg, ← neg_smul, smul_smul] + congr 1 + congr 1 + rw [maurerCartanForm_toU1Value, hpow, Algebra.smul_def, Algebra.smul_def, + Algebra.smul_def, map_ofNat] + linear_combination (4 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) ^ 4) * hiC + - (4 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) ^ 3) * huu + +/-- **The equivariance identity** for the colour matrix of the jet gauge action: the + colour matrix intertwines the constant jet action matrix with its adjoint + transform. -/ +lemma upMatrix_mul_jetActionMatrix (U : JetGaugeGroupI) (c : GaugeAlgebra) : + upMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = jetActionMatrix (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c)) + * upMatrix U := by + have hU₃u : star U.1.1 * U.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rw [upMatrix, jetActionMatrix, jetActionMatrix, + JetGaugeAlgebra.adjointMap_toSU3Matrix, JetGaugeAlgebra.adjointMap_toU1Value] + conv_lhs => rw [Matrix.mul_smul, Matrix.smul_mul, Matrix.mul_add, Matrix.mul_smul, + Matrix.mul_one] + conv_rhs => rw [Matrix.smul_mul, Matrix.add_mul, Matrix.mul_smul, + Matrix.smul_mul, Matrix.one_mul, Matrix.mul_assoc, hU₃u, Matrix.mul_one] + rw [smul_add, smul_comm ((((U.2.2 : unitary JetRing) : JetRing)) ^ 4) + ((4 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +set_option maxHeartbeats 1000000 in +/-- **The base-point Taylor coefficients of the jet gauge action** on the up-type + singlet are the colour endomorphisms of the base-point Taylor coefficients of the + colour matrix. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = colourEnd ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + refine LinearMap.ext fun d => ?_ + apply valLinEquiv.injective + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x d + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant d))) from rfl, + valLinEquiv_jetEval, jetValLinEquiv_jetIteratedDeriv, + colourEnd_apply_mk, LinearEquiv.apply_symm_apply, + repJetGaugeGroupI_eq_upMatrix, LinearEquiv.apply_symm_apply, + StandardModel.jetOfConstant_apply] + obtain ⟨w⟩ := d + induction w using TensorProduct.induction_on with + | zero => + rw [show ({ val := 0 } : UpSinglet) = 0 from rfl, TensorProduct.tmul_zero] + simp + rw [show (0 : UpSinglet).val = 0 from rfl, map_zero] + | add a b ha hb => + rw [show ({ val := a + b } : UpSinglet) = ⟨a⟩ + ⟨b⟩ from rfl, + TensorProduct.tmul_add, map_add, map_add, map_add, map_add, ha, hb, map_add, + map_add] + | tmul ψ c => + rw [show jetValLinEquiv ((1 : JetRing) ⊗ₜ[ℂ] (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet)) + = ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing)) from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace JetRing (Fin 3)) + Fermion.RightHandedWeyl + ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)).restrictScalars ℂ)) + (ψ ⊗ₜ[ℂ] (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))) from rfl, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, + show valLinEquiv (⟨ψ ⊗ₜ[ℂ] c⟩ : UpSinglet) = ψ ⊗ₜ[ℂ] c from rfl, + show (Module.End.lTensorAlgHom ℂ (EuclideanSpace ℂ (Fin 3)) + Fermion.RightHandedWeyl + (Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)))) (ψ ⊗ₜ[ℂ] c) + = ψ ⊗ₜ[ℂ] ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c) from rfl] + congr 1 + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (upMatrix U)) + (WithLp.toLp 2 fun i => c.ofLp i • (1 : JetRing))).ofLp j + = ∑ k, upMatrix U j k * (c.ofLp k • (1 : JetRing)) from by + simp [Matrix.mulVec_eq_sum, + Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) c).ofLp j + = ∑ k, constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (upMatrix U j k)) + * c.ofLp k from by + simp [Matrix.mulVec_eq_sum, + Finset.sum_apply, mul_comm], + JetRing.foldl_pderiv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + mul_comm] + + +/-- The colour endomorphism of the identity matrix is the identity. -/ +lemma colourEnd_one : colourEnd 1 = LinearMap.id := by + refine LinearMap.ext fun v => ?_ + rw [colourEnd_apply_mk, map_one, map_one, Module.End.one_apply, + LinearEquiv.symm_apply_apply, LinearMap.id_apply] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h1 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.1 : specialUnitaryGroup (Fin 3) JetRing) : Matrix (Fin 3) (Fin 3) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg Prod.fst hU) + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((upMatrix U).map fun f => + constantCoeff ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, Multiset.foldl_zero, upMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, hu, one_pow, one_mul] + exact Matrix.ext_iff.mpr h1 i j + rw [repCoeff_eq, hM, colourEnd_one] + +set_option maxHeartbeats 1000000 in +/-- **The `(3, 1)_{4}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the up-type singlet**: its base-point Taylor + coefficients obey the Maurer–Cartan Leibniz law and intertwine the action with the + adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : ((upMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((upMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum) := by + rw [show ((upMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (((upMatrix U).map fun f => pderiv ℂ μ f).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + Multiset.foldl_cons], + upMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * upMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * upMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, foldl_pderiv_neg, map_neg], + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [jetActionMatrix_map_cc_foldl])) + rw [repCoeff_eq, hMcons, colourEnd_neg, colourEnd_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, colourEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hCsmul : ∀ z w : ℂ, (z • (C w : JetRing)) = C (z * w) := fun z w => by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + Algebra.algebraMap_self_apply, ← map_mul] + have hconst : jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = (actionMatrix c).map (C : ℂ → JetRing) := by + refine Matrix.ext fun i j => ?_ + rw [jetActionMatrix, actionMatrix, JetGaugeAlgebra.ofConstant_toSU3Matrix, + JetGaugeAlgebra.ofConstant_toU1Value, Matrix.map_apply, Matrix.smul_apply, + Matrix.add_apply, Matrix.map_apply, Matrix.smul_apply, Matrix.smul_apply, + Matrix.add_apply, Matrix.smul_apply] + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq] + simp only [smul_eq_mul, mul_one] + rw [hCsmul, ← map_add, hCsmul] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + add_zero, add_zero, hCsmul] + exact congrArg C (by ring) + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((actionMatrix c).map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then actionMatrix c else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, constantCoeff_C] + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (IsGaugeField.adjointCoeff U p.1 c) + * ((upMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have h1 : ((upMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c := by + rw [hconst, matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((upMatrix U).map fun f => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p hp => by rw [if_neg hp, Matrix.mul_zero]), + if_pos rfl] + rw [← h1, upMatrix_mul_jetActionMatrix, matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [jetActionMatrix_map_cc_foldl, + show JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c))) + = IsGaugeField.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (colourEnd ((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + ∘ₗ gaugeAlgebraAction c + = colourEnd (((upMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c) from by + rw [colourEnd_mul]; rfl, + hMact, colourEnd_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, colourEnd_mul, repCoeff_eq] + rfl + +end InfinitesimalAction + +end UpSinglet + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean new file mode 100644 index 000000000..706e255d2 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/Basic.lean @@ -0,0 +1,294 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +/-! +# The gauge algebra of the Standard Model + +The gauge algebra of the Standard Model is the Lie algebra of +`GaugeGroupI`, which is the direct sum of the Lie algebras of `SU(3)`, `SU(2)` and `U(1)`. +This is a matrix Lie algebra, so the bracket is given by the commutator of matrices. + +-/ + +@[expose] public section + +namespace StandardModel +open MvPowerSeries Matrix + +/-- The gauge algebra of the Standard Model: the Lie algebra of `GaugeGroupI`, with one + factor per gauge group factor — traceless self-adjoint `3 × 3` and `2 × 2` complex + matrices and a self-adjoint (i.e. real) scalar. This is the constant-coefficient + analogue of `JetGaugeAlgebra`, and the value at the base point of the jets it contains. -/ +abbrev GaugeAlgebra := + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 3) (Fin 3) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 3) ℝ ℂ)) × + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 2) (Fin 2) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 2) ℝ ℂ)) × + selfAdjoint ℂ + +/-- The self-adjoint scalars form a finite-dimensional real vector space, through the + identification with the corresponding submodule. -/ +instance : Module.Finite ℝ (selfAdjoint ℂ) := + inferInstanceAs (Module.Finite ℝ (selfAdjoint.submodule ℝ ℂ)) + +instance : Module.Finite ℝ GaugeAlgebra := by infer_instance + +namespace GaugeAlgebra + +/-! + +## Basic projections + +-/ + +/-- The `su(3)`-factor component of an element of the gauge algebra. -/ +def toSU3Matrix (a : GaugeAlgebra) : Matrix (Fin 3) (Fin 3) ℂ := a.1 + +/-- The `su(2)`-factor component of an element of the gauge algebra. -/ +def toSU2Matrix (a : GaugeAlgebra) : Matrix (Fin 2) (Fin 2) ℂ := a.2.1 + +/-- The `u(1)`-factor component of an element of the gauge algebra. -/ +def toU1Value (a : GaugeAlgebra) : ℂ := a.2.2 + +@[ext] +lemma ext_of_matrix {a b : GaugeAlgebra} (h1 : a.toSU3Matrix = b.toSU3Matrix) + (h2 : a.toSU2Matrix = b.toSU2Matrix) (h3 : a.toU1Value = b.toU1Value) : a = b := by + cases a; cases b + simp only [toSU3Matrix, toSU2Matrix, toU1Value] at h1 h2 h3 + grind + +/-! + +## Constructor from a product of matrices + +-/ + +/-- The element of the gauge algebra constructed from a triple of matrices satisfying + the relevant hermiticity and tracelessness conditions. -/ +def ofMatrixProd (A : Matrix (Fin 3) (Fin 3) ℂ × + Matrix (Fin 2) (Fin 2) ℂ × ℂ) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : GaugeAlgebra := + ⟨⟨A.1, hA⟩, ⟨A.2.1, hB⟩, ⟨A.2.2, hC⟩⟩ + +@[simp] +lemma ofMatrixProd_toSU3Matrix (A : Matrix (Fin 3) (Fin 3) ℂ × + Matrix (Fin 2) (Fin 2) ℂ × ℂ) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toSU3Matrix = A.1 := by rfl + +@[simp] +lemma ofMatrixProd_toSU2Matrix (A : Matrix (Fin 3) (Fin 3) ℂ × + Matrix (Fin 2) (Fin 2) ℂ × ℂ) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toSU2Matrix = A.2.1 := by rfl + +@[simp] +lemma ofMatrixProd_toU1Value (A : Matrix (Fin 3) (Fin 3) ℂ × + Matrix (Fin 2) (Fin 2) ℂ × ℂ) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toU1Value = A.2.2 := by rfl + +/-! + +## The Lie algebra instance + +-/ + +@[simp] +lemma add_toSU3Matrix (a b : GaugeAlgebra) : + (a + b).toSU3Matrix = a.toSU3Matrix + b.toSU3Matrix := by rfl + +@[simp] +lemma add_toSU2Matrix (a b : GaugeAlgebra) : + (a + b).toSU2Matrix = a.toSU2Matrix + b.toSU2Matrix := by rfl + +@[simp] +lemma add_toU1Value (a b : GaugeAlgebra) : + (a + b).toU1Value = a.toU1Value + b.toU1Value := by rfl + +@[simp] +lemma zero_toSU3Matrix : (0 : GaugeAlgebra).toSU3Matrix = 0 := by rfl + +@[simp] +lemma zero_toSU2Matrix : (0 : GaugeAlgebra).toSU2Matrix = 0 := by rfl + +@[simp] +lemma zero_toU1Value : (0 : GaugeAlgebra).toU1Value = 0 := by rfl + +@[simp] +lemma smul_toSU3Matrix (r : ℝ) (a : GaugeAlgebra) : + (r • a).toSU3Matrix = r • a.toSU3Matrix := by rfl + +@[simp] +lemma smul_toSU2Matrix (r : ℝ) (a : GaugeAlgebra) : + (r • a).toSU2Matrix = r • a.toSU2Matrix := by rfl + +@[simp] +lemma smul_toU1Value (r : ℝ) (a : GaugeAlgebra) : + (r • a).toU1Value = r • a.toU1Value := by rfl + +/-- The bracket on the gauge algebra: `I` times the matrix commutator on the + `su(3)` and `su(2)` factors, and zero on the (commutative) `u(1)` factor. The + factor of `I` is what makes the bracket of two hermitian matrices hermitian + again; it is also why the bracket is only `ℝ`-bilinear, not `ℂ`-bilinear. -/ +noncomputable instance : Bracket GaugeAlgebra GaugeAlgebra where + bracket a b := ofMatrixProd + (Complex.I • (a.toSU3Matrix * b.toSU3Matrix - b.toSU3Matrix * a.toSU3Matrix), + Complex.I • (a.toSU2Matrix * b.toSU2Matrix - b.toSU2Matrix * a.toSU2Matrix), + 0) + ⟨by + rw [star_smul, star_sub, star_mul, star_mul, + show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1, + show star b.toSU3Matrix = b.toSU3Matrix from b.1.2.1, + Complex.star_def, Complex.conj_I, neg_smul, ← smul_neg, neg_sub], + by rw [Matrix.trace_smul, Matrix.trace_sub, Matrix.trace_mul_comm, sub_self, smul_zero]⟩ + ⟨by + rw [star_smul, star_sub, star_mul, star_mul, + show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1, + show star b.toSU2Matrix = b.toSU2Matrix from b.2.1.2.1, + Complex.star_def, Complex.conj_I, neg_smul, ← smul_neg, neg_sub], + by rw [Matrix.trace_smul, Matrix.trace_sub, Matrix.trace_mul_comm, sub_self, smul_zero]⟩ + (star_zero _) + +@[simp] +lemma bracket_toSU3Matrix (a b : GaugeAlgebra) : + ⁅a, b⁆.toSU3Matrix = + Complex.I • (a.toSU3Matrix * b.toSU3Matrix - b.toSU3Matrix * a.toSU3Matrix) := rfl + +@[simp] +lemma bracket_toSU2Matrix (a b : GaugeAlgebra) : + ⁅a, b⁆.toSU2Matrix = + Complex.I • (a.toSU2Matrix * b.toSU2Matrix - b.toSU2Matrix * a.toSU2Matrix) := rfl + +@[simp] +lemma bracket_toU1Value (a b : GaugeAlgebra) : + ⁅a, b⁆.toU1Value = 0 := rfl + +noncomputable instance : LieRing GaugeAlgebra where + add_lie a b c := by + ext <;> simp [add_mul, mul_add, smul_sub] <;> ring + lie_add a b c := by + ext <;> simp [add_mul, mul_add, smul_sub] <;> ring + lie_self a := by + ext <;> simp + leibniz_lie a b c := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [bracket_toSU3Matrix, bracket_toSU2Matrix, bracket_toU1Value, + add_toSU3Matrix, add_toSU2Matrix, add_toU1Value, mul_smul_comm, smul_mul_assoc, + smul_smul, Complex.I_mul_I, smul_sub, mul_sub, sub_mul, mul_assoc, add_zero] <;> + module + +noncomputable instance : LieAlgebra ℝ GaugeAlgebra where + lie_smul t a b := by + ext <;> simp [smul_sub] <;> ring + +/-! + +## The adjoint action of the global gauge group + +-/ + +/-- The conjugate of a hermitian traceless matrix by a unitary matrix is hermitian and + traceless. -/ +lemma conj_mem {n : ℕ} {U A : Matrix (Fin n) (Fin n) ℂ} + (hU : U ∈ Matrix.unitaryGroup (Fin n) ℂ) (hA : star A = A) (htr : A.trace = 0) : + star (U * A * star U) = U * A * star U ∧ (U * A * star U).trace = 0 := by + constructor + · rw [star_mul, star_mul, star_star, hA, mul_assoc] + · rw [Matrix.trace_mul_cycle, Matrix.mem_unitaryGroup_iff'.mp hU, one_mul, htr] + +/-- The linear map by which one gauge group element acts on the gauge algebra in the + adjoint action: conjugation by the corresponding unitary on the `su(3)` and `su(2)` + factors, and the identity on the commutative `u(1)` factor. -/ +noncomputable def adjointMap (g : GaugeGroupI) : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra where + toFun a := ofMatrixProd + (g.toSU3.1 * a.toSU3Matrix * star g.toSU3.1, + g.toSU2.1 * a.toSU2Matrix * star g.toSU2.1, + a.toU1Value) + (conj_mem g.toSU3.2.1 a.1.2.1 a.1.2.2) + (conj_mem g.toSU2.2.1 a.2.1.2.1 a.2.1.2.2) + a.2.2.2 + map_add' a b := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [ofMatrixProd_toSU3Matrix, ofMatrixProd_toSU2Matrix, ofMatrixProd_toU1Value, + add_toSU3Matrix, add_toSU2Matrix, add_toU1Value, mul_add, add_mul] + map_smul' r a := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [ofMatrixProd_toSU3Matrix, ofMatrixProd_toSU2Matrix, ofMatrixProd_toU1Value, + smul_toSU3Matrix, smul_toSU2Matrix, smul_toU1Value, RingHom.id_apply, + Matrix.mul_smul, Matrix.smul_mul] + +@[simp] +lemma adjointMap_toSU3Matrix (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjointMap g a).toSU3Matrix = g.toSU3.1 * a.toSU3Matrix * star g.toSU3.1 := rfl + +@[simp] +lemma adjointMap_toSU2Matrix (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjointMap g a).toSU2Matrix = g.toSU2.1 * a.toSU2Matrix * star g.toSU2.1 := rfl + +@[simp] +lemma adjointMap_toU1Value (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjointMap g a).toU1Value = a.toU1Value := rfl + +/-- **The adjoint action of the global gauge group on its gauge algebra**: conjugation by + the corresponding unitary on the `su(3)` and `su(2)` factors, and the trivial action on + the commutative `u(1)` factor. -/ +noncomputable def adjoint : Representation ℝ GaugeGroupI GaugeAlgebra where + toFun := adjointMap + map_one' := by + refine LinearMap.ext fun a => ext_of_matrix ?_ ?_ ?_ + · rw [adjointMap_toSU3Matrix, + show ((1 : GaugeGroupI).toSU3.1 : Matrix (Fin 3) (Fin 3) ℂ) = 1 from rfl, + one_mul, star_one, mul_one] + rfl + · rw [adjointMap_toSU2Matrix, + show ((1 : GaugeGroupI).toSU2.1 : Matrix (Fin 2) (Fin 2) ℂ) = 1 from rfl, + one_mul, star_one, mul_one] + rfl + · rfl + map_mul' g₁ g₂ := by + refine LinearMap.ext fun a => ext_of_matrix ?_ ?_ ?_ + · rw [Module.End.mul_apply, adjointMap_toSU3Matrix, adjointMap_toSU3Matrix, + adjointMap_toSU3Matrix, + show ((g₁ * g₂).toSU3.1 : Matrix (Fin 3) (Fin 3) ℂ) = g₁.toSU3.1 * g₂.toSU3.1 from rfl, + star_mul] + simp only [mul_assoc] + · rw [Module.End.mul_apply, adjointMap_toSU2Matrix, adjointMap_toSU2Matrix, + adjointMap_toSU2Matrix, + show ((g₁ * g₂).toSU2.1 : Matrix (Fin 2) (Fin 2) ℂ) = g₁.toSU2.1 * g₂.toSU2.1 from rfl, + star_mul] + simp only [mul_assoc] + · rw [Module.End.mul_apply, adjointMap_toU1Value, adjointMap_toU1Value, + adjointMap_toU1Value] + +@[simp] +lemma adjoint_toSU3Matrix (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjoint g a).toSU3Matrix = g.toSU3.1 * a.toSU3Matrix * star g.toSU3.1 := rfl + +@[simp] +lemma adjoint_toSU2Matrix (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjoint g a).toSU2Matrix = g.toSU2.1 * a.toSU2Matrix * star g.toSU2.1 := rfl + +@[simp] +lemma adjoint_toU1Value (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjoint g a).toU1Value = a.toU1Value := rfl + +end GaugeAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeAlgebra/Basis.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/Basis.lean new file mode 100644 index 000000000..914b0df6f --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/Basis.lean @@ -0,0 +1,743 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basic +public import Physlib.Relativity.PauliMatrices.Basic +public import Mathlib.LinearAlgebra.Basis.Basic +public import Mathlib.LinearAlgebra.Basis.Prod +public import Mathlib.Analysis.Real.Sqrt +public import Mathlib.Algebra.BigOperators.Fin +/-! +# The standard basis of the gauge algebra + +The standard basis of the gauge algebra of the Standard Model, indexed by +`Fin 8 ⊕ Fin 3 ⊕ Fin 1`: the eight Gell-Mann matrices on the `su(3)` factor, the three +Pauli matrices on the `su(2)` factor, and `1` on the `u(1)` factor. + +In this basis the adjoint action of the gauge group is the block-diagonal matrix +`adjointMatrix`, whose blocks are the trace pairings of the basis elements with their +conjugates; `adjoint_stdBasis` and `toMatrix_adjoint` identify its action with the +adjoint action. + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix Module PauliMatrix + +noncomputable section + +/-! + +## A. The Gell-Mann matrices + +The Pauli matrices `σ1`, `σ2`, `σ3` embedded along the three coordinate planes of +`Fin 3`, together with the normalised traceless diagonal matrix. + +-/ + +/-- The embedding of `2 × 2` matrices into the `3 × 3` matrices supported on the plane + of two coordinate directions: the entries of `A` land at the row and column indices + `p 0` and `p 1`, every other entry vanishing. -/ +def planeEmbed (p : Fin 2 → Fin 3) (A : Matrix (Fin 2) (Fin 2) ℂ) : + Matrix (Fin 3) (Fin 3) ℂ := + Matrix.of fun i j => ∑ a, ∑ b, if i = p a ∧ j = p b then A a b else 0 + +/-- The Gell-Mann matrices: the standard basis of the traceless hermitian `3 × 3` + matrices. The first seven are the Pauli matrices `σ1`, `σ2`, `σ3` embedded along the + three coordinate planes; the eighth is the normalised traceless diagonal matrix. -/ +def gellMannMatrix : Fin 8 → Matrix (Fin 3) (Fin 3) ℂ + | 0 => planeEmbed ![0, 1] σ1 + | 1 => planeEmbed ![0, 1] σ2 + | 2 => planeEmbed ![0, 1] σ3 + | 3 => planeEmbed ![0, 2] σ1 + | 4 => planeEmbed ![0, 2] σ2 + | 5 => planeEmbed ![1, 2] σ1 + | 6 => planeEmbed ![1, 2] σ2 + | 7 => (((Real.sqrt 3 : ℝ) : ℂ))⁻¹ • !![1, 0, 0; 0, 1, 0; 0, 0, -2] + +lemma gellMannMatrix_zero : gellMannMatrix 0 = !![0, 1, 0; 1, 0, 0; 0, 0, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_one : + gellMannMatrix 1 = !![0, -Complex.I, 0; Complex.I, 0, 0; 0, 0, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_two : gellMannMatrix 2 = !![1, 0, 0; 0, -1, 0; 0, 0, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_three : gellMannMatrix 3 = !![0, 0, 1; 0, 0, 0; 1, 0, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_four : + gellMannMatrix 4 = !![0, 0, -Complex.I; 0, 0, 0; Complex.I, 0, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_five : gellMannMatrix 5 = !![0, 0, 0; 0, 0, 1; 0, 1, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_six : + gellMannMatrix 6 = !![0, 0, 0; 0, 0, -Complex.I; 0, Complex.I, 0] := by + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix, planeEmbed, pauliMatrix, Fin.sum_univ_two] + +lemma gellMannMatrix_seven : + gellMannMatrix 7 = (((Real.sqrt 3 : ℝ) : ℂ))⁻¹ • !![1, 0, 0; 0, 1, 0; 0, 0, -2] := rfl + +/-- The Gell-Mann matrices are hermitian. -/ +lemma gellMannMatrix_selfAdjoint (k : Fin 8) : + star (gellMannMatrix k) = gellMannMatrix k := by + fin_cases k <;> + · rw [Matrix.star_eq_conjTranspose] + ext i j + fin_cases i <;> fin_cases j <;> + simp [gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two, gellMannMatrix_three, + gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six, gellMannMatrix_seven, + Matrix.conjTranspose_apply, Complex.conj_ofReal] + +/-- The Gell-Mann matrices are traceless. -/ +lemma gellMannMatrix_trace (k : Fin 8) : (gellMannMatrix k).trace = 0 := by + fin_cases k + all_goals + simp [gellMannMatrix_zero, gellMannMatrix_one, gellMannMatrix_two, gellMannMatrix_three, + gellMannMatrix_four, gellMannMatrix_five, gellMannMatrix_six, gellMannMatrix_seven, + Matrix.trace_fin_three] + all_goals ring + +/-- A combination of the Gell-Mann matrices, entry by entry. -/ +lemma sum_smul_gellMannMatrix (g : Fin 8 → ℝ) : + ∑ k, g k • gellMannMatrix k = + !![((g 2 + (Real.sqrt 3)⁻¹ * g 7 : ℝ) : ℂ), + ((g 0 : ℝ) : ℂ) - ((g 1 : ℝ) : ℂ) * Complex.I, + ((g 3 : ℝ) : ℂ) - ((g 4 : ℝ) : ℂ) * Complex.I; + ((g 0 : ℝ) : ℂ) + ((g 1 : ℝ) : ℂ) * Complex.I, + ((-g 2 + (Real.sqrt 3)⁻¹ * g 7 : ℝ) : ℂ), + ((g 5 : ℝ) : ℂ) - ((g 6 : ℝ) : ℂ) * Complex.I; + ((g 3 : ℝ) : ℂ) + ((g 4 : ℝ) : ℂ) * Complex.I, + ((g 5 : ℝ) : ℂ) + ((g 6 : ℝ) : ℂ) * Complex.I, + ((-2 * (Real.sqrt 3)⁻¹ * g 7 : ℝ) : ℂ)] := by + ext i j + fin_cases i <;> fin_cases j + all_goals + simp [Fin.sum_univ_eight, Matrix.sum_apply, gellMannMatrix_zero, gellMannMatrix_one, + gellMannMatrix_two, gellMannMatrix_three, gellMannMatrix_four, gellMannMatrix_five, + gellMannMatrix_six, gellMannMatrix_seven, Complex.real_smul] + all_goals ring + +/-- A combination of the three Pauli matrices `σ1`, `σ2`, `σ3`, entry by entry. -/ +lemma sum_smul_pauliMatrix_inr (g : Fin 3 → ℝ) : + ∑ i, g i • pauliMatrix (Sum.inr i) = + !![((g 2 : ℝ) : ℂ), ((g 0 : ℝ) : ℂ) - ((g 1 : ℝ) : ℂ) * Complex.I; + ((g 0 : ℝ) : ℂ) + ((g 1 : ℝ) : ℂ) * Complex.I, ((-g 2 : ℝ) : ℂ)] := by + ext i j + fin_cases i <;> fin_cases j + all_goals + simp [Fin.sum_univ_three, Matrix.sum_apply, pauliMatrix, Complex.real_smul] + all_goals ring + +/-- The Pauli matrices `σ1`, `σ2`, `σ3` are hermitian, phrased through `star`. -/ +lemma pauliMatrix_inr_star (i : Fin 3) : + star (pauliMatrix (Sum.inr i)) = pauliMatrix (Sum.inr i) := by + rw [Matrix.star_eq_conjTranspose] + exact pauliMatrix_selfAdjoint _ + +/-- The Pauli matrices `σ1`, `σ2`, `σ3` are traceless. -/ +lemma pauliMatrix_inr_trace (i : Fin 3) : (pauliMatrix (Sum.inr i)).trace = 0 := by + fin_cases i <;> simp [pauliMatrix, Matrix.trace_fin_two] + +/-! + +## B. Coordinates in the Gell-Mann and Pauli bases + +The coordinates of a traceless hermitian matrix in the Gell-Mann and Pauli bases, read +off from its entries; they coincide with the trace pairings +`2⁻¹ * (trace (T k * M)).re` with the basis matrices. + +-/ + +/-- The entries of a hermitian matrix are conjugate-symmetric. -/ +lemma entry_symm_of_star_eq {n : ℕ} {M : Matrix (Fin n) (Fin n) ℂ} (hsa : star M = M) + (i j : Fin n) : M j i = (starRingEnd ℂ) (M i j) := by + conv_lhs => rw [← hsa] + rw [Matrix.star_apply] + rfl + +/-- The diagonal entries of a hermitian matrix are real. -/ +lemma diag_re_of_star_eq {n : ℕ} {M : Matrix (Fin n) (Fin n) ℂ} (hsa : star M = M) + (i : Fin n) : M i i = ((M i i).re : ℂ) := + (Complex.conj_eq_iff_re.mp (entry_symm_of_star_eq hsa i i).symm).symm + +/-- The coordinates of a matrix in the Gell-Mann basis, read off from its entries. -/ +def gellMannCoeff (M : Matrix (Fin 3) (Fin 3) ℂ) : Fin 8 → ℝ + | 0 => (M 0 1).re + | 1 => -(M 0 1).im + | 2 => ((M 0 0).re - (M 1 1).re) / 2 + | 3 => (M 0 2).re + | 4 => -(M 0 2).im + | 5 => (M 1 2).re + | 6 => -(M 1 2).im + | 7 => Real.sqrt 3 / 2 * ((M 0 0).re + (M 1 1).re) + +/-- The coordinates of a matrix in the Pauli basis `σ1`, `σ2`, `σ3`, read off from its + entries. -/ +def pauliCoeff (M : Matrix (Fin 2) (Fin 2) ℂ) : Fin 3 → ℝ + | 0 => (M 0 1).re + | 1 => -(M 0 1).im + | 2 => (M 0 0).re + +/-- A traceless hermitian `3 × 3` matrix is the combination of the Gell-Mann matrices + with its `gellMannCoeff` coordinates. -/ +lemma eq_sum_gellMannCoeff_smul {M : Matrix (Fin 3) (Fin 3) ℂ} + (hsa : star M = M) (htr : M.trace = 0) : + M = ∑ k, gellMannCoeff M k • gellMannMatrix k := by + have hherm := entry_symm_of_star_eq hsa + have hdiag := diag_re_of_star_eq hsa + have htr3 : M 2 2 = -(M 0 0 + M 1 1) := by + rw [Matrix.trace_fin_three] at htr + linear_combination htr + have hs : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) + rw [sum_smul_gellMannMatrix] + simp only [gellMannCoeff] + generalize hgen : Real.sqrt 3 = s at hs ⊢ + have hsc : ((s : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hs + ext i j + match i, j with + | 0, 0 => + conv_lhs => rw [hdiag 0] + simp + field_simp + ring + | 0, 1 => simp + | 0, 2 => simp + | 1, 0 => + conv_lhs => rw [hherm 0 1] + simp + apply Complex.ext <;> simp + | 1, 1 => + conv_lhs => rw [hdiag 1] + simp + field_simp + ring + | 1, 2 => simp + | 2, 0 => + conv_lhs => rw [hherm 0 2] + simp + apply Complex.ext <;> simp + | 2, 1 => + conv_lhs => rw [hherm 1 2] + simp + apply Complex.ext <;> simp + | 2, 2 => + conv_lhs => rw [htr3] + conv_lhs => rw [hdiag 0] + conv_lhs => rw [hdiag 1] + simp + field_simp + ring + +/-- A traceless hermitian `2 × 2` matrix is the combination of the Pauli matrices + `σ1`, `σ2`, `σ3` with its `pauliCoeff` coordinates. -/ +lemma eq_sum_pauliCoeff_smul {M : Matrix (Fin 2) (Fin 2) ℂ} + (hsa : star M = M) (htr : M.trace = 0) : + M = ∑ i, pauliCoeff M i • pauliMatrix (Sum.inr i) := by + have hherm := entry_symm_of_star_eq hsa + have hdiag := diag_re_of_star_eq hsa + have htr2 : M 1 1 = -M 0 0 := by + rw [Matrix.trace_fin_two] at htr + linear_combination htr + rw [sum_smul_pauliMatrix_inr] + simp only [pauliCoeff] + ext i j + match i, j with + | 0, 0 => + conv_lhs => rw [hdiag 0] + simp + | 0, 1 => simp + | 1, 0 => + conv_lhs => rw [hherm 0 1] + simp + apply Complex.ext <;> simp + | 1, 1 => + conv_lhs => rw [htr2] + conv_lhs => rw [hdiag 0] + simp + +/-- The Gell-Mann coordinates of a traceless hermitian matrix are its trace pairings + with the Gell-Mann matrices. -/ +lemma gellMannCoeff_eq_trace {M : Matrix (Fin 3) (Fin 3) ℂ} + (hsa : star M = M) (htr : M.trace = 0) (k : Fin 8) : + gellMannCoeff M k = 2⁻¹ * (Matrix.trace (gellMannMatrix k * M)).re := by + have hherm := entry_symm_of_star_eq hsa + have hdiag := diag_re_of_star_eq hsa + have htr3 : M 2 2 = -(M 0 0 + M 1 1) := by + rw [Matrix.trace_fin_three] at htr + linear_combination htr + match k with + | 0 => + rw [gellMannMatrix_zero] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 0 1] + ring + | 1 => + rw [gellMannMatrix_one] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 0 1] + ring + | 2 => + rw [gellMannMatrix_two] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three] + ring + | 3 => + rw [gellMannMatrix_three] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 0 2] + ring + | 4 => + rw [gellMannMatrix_four] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 0 2] + ring + | 5 => + rw [gellMannMatrix_five] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 1 2] + ring + | 6 => + rw [gellMannMatrix_six] + simp only [gellMannCoeff] + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three, hherm 1 2] + ring + | 7 => + have h33 : Real.sqrt 3 * Real.sqrt 3 = 3 := Real.mul_self_sqrt (by norm_num) + have hs : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) + rw [gellMannMatrix_seven] + simp only [gellMannCoeff] + rw [Matrix.smul_mul, Matrix.trace_smul] + rw [show Matrix.trace (!![1, 0, 0; 0, 1, 0; 0, 0, -2] * M) + = M 0 0 + M 1 1 - 2 * M 2 2 by + rw [Matrix.trace_fin_three, Matrix.mul_apply, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_three] + ring] + rw [htr3, hdiag 0, hdiag 1] + rw [show (((Real.sqrt 3 : ℝ) : ℂ))⁻¹ = (((Real.sqrt 3)⁻¹ : ℝ) : ℂ) by push_cast; ring] + rw [smul_eq_mul, Complex.re_ofReal_mul] + simp + field_simp + linear_combination ((M 0 0).re + (M 1 1).re) * h33 + +/-- The Pauli coordinates of a traceless hermitian matrix are its trace pairings with + the Pauli matrices `σ1`, `σ2`, `σ3`. -/ +lemma pauliCoeff_eq_trace {M : Matrix (Fin 2) (Fin 2) ℂ} + (hsa : star M = M) (htr : M.trace = 0) (i : Fin 3) : + pauliCoeff M i = 2⁻¹ * (Matrix.trace (pauliMatrix (Sum.inr i) * M)).re := by + have hherm := entry_symm_of_star_eq hsa + have htr2 : M 1 1 = -M 0 0 := by + rw [Matrix.trace_fin_two] at htr + linear_combination htr + match i with + | 0 => + simp only [pauliCoeff] + rw [Matrix.trace_fin_two, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_two, pauliMatrix, hherm 0 1] + ring + | 1 => + simp only [pauliCoeff] + rw [Matrix.trace_fin_two, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_two, pauliMatrix, hherm 0 1] + ring + | 2 => + simp only [pauliCoeff] + rw [Matrix.trace_fin_two, Matrix.mul_apply, Matrix.mul_apply] + simp [Fin.sum_univ_two, pauliMatrix, htr2] + ring + +namespace GaugeAlgebra + +/-! + +## C. The Gell-Mann basis of the su(3) factor + +-/ + +/-- The Gell-Mann matrices as elements of the `su(3)` factor of the gauge algebra. -/ +def gellMannSU3 (k : Fin 8) : + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 3) (Fin 3) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 3) ℝ ℂ)) := + ⟨gellMannMatrix k, gellMannMatrix_selfAdjoint k, gellMannMatrix_trace k⟩ + +@[simp] +lemma coe_gellMannSU3 (k : Fin 8) : + (gellMannSU3 k : Matrix (Fin 3) (Fin 3) ℂ) = gellMannMatrix k := rfl + +/-- The Gell-Mann matrices are linearly independent. -/ +lemma gellMannSU3_linearIndependent : LinearIndependent ℝ gellMannSU3 := by + apply Fintype.linearIndependent_iff.mpr + intro g hg + have hM : ∑ k, g k • gellMannMatrix k = (0 : Matrix (Fin 3) (Fin 3) ℂ) := by + simpa [gellMannSU3] using congrArg Subtype.val hg + rw [sum_smul_gellMannMatrix] at hM + have h00 := congrFun (congrFun hM 0) 0 + have h11 := congrFun (congrFun hM 1) 1 + have h01 := congrFun (congrFun hM 0) 1 + have h02 := congrFun (congrFun hM 0) 2 + have h12 := congrFun (congrFun hM 1) 2 + simp [Complex.ext_iff] at h00 h11 h01 h02 h12 + obtain ⟨h0, h1⟩ := h01 + obtain ⟨h3, h4⟩ := h02 + obtain ⟨h5, h6⟩ := h12 + have hs : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) + have h2 : g 2 = 0 := by linarith + have hx : Real.sqrt 3 * g 7 = 0 := by linarith + have h7 : g 7 = 0 := (mul_eq_zero.mp hx).resolve_left hs + intro k + fin_cases k <;> assumption + +/-- The Gell-Mann matrices span the `su(3)` factor. -/ +lemma gellMannSU3_span : ⊤ ≤ Submodule.span ℝ (Set.range gellMannSU3) := by + refine (Submodule.top_le_span_range_iff_forall_exists_fun ℝ).mpr fun A => ?_ + refine ⟨gellMannCoeff (A : Matrix (Fin 3) (Fin 3) ℂ), Subtype.ext ?_⟩ + rw [AddSubmonoidClass.coe_finsetSum] + simp only [SetLike.val_smul, coe_gellMannSU3] + exact (eq_sum_gellMannCoeff_smul A.2.1 A.2.2).symm + +/-- The Gell-Mann basis of the `su(3)` factor of the gauge algebra. -/ +def su3Basis : Basis (Fin 8) ℝ + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 3) (Fin 3) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 3) ℝ ℂ)) := + Basis.mk gellMannSU3_linearIndependent gellMannSU3_span + +@[simp] +lemma su3Basis_apply (k : Fin 8) : su3Basis k = gellMannSU3 k := by + rw [su3Basis, Basis.mk_apply] + +/-! + +## D. The Pauli basis of the su(2) factor + +-/ + +/-- The Pauli matrices `σ1`, `σ2`, `σ3` as elements of the `su(2)` factor of the gauge + algebra. -/ +def pauliSU2 (i : Fin 3) : + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 2) (Fin 2) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 2) ℝ ℂ)) := + ⟨pauliMatrix (Sum.inr i), pauliMatrix_inr_star i, pauliMatrix_inr_trace i⟩ + +@[simp] +lemma coe_pauliSU2 (i : Fin 3) : + (pauliSU2 i : Matrix (Fin 2) (Fin 2) ℂ) = pauliMatrix (Sum.inr i) := rfl + +/-- The Pauli matrices `σ1`, `σ2`, `σ3` are linearly independent. -/ +lemma pauliSU2_linearIndependent : LinearIndependent ℝ pauliSU2 := by + apply Fintype.linearIndependent_iff.mpr + intro g hg + have hM : ∑ i, g i • pauliMatrix (Sum.inr i) = (0 : Matrix (Fin 2) (Fin 2) ℂ) := by + simpa [pauliSU2] using congrArg Subtype.val hg + rw [sum_smul_pauliMatrix_inr] at hM + have h00 := congrFun (congrFun hM 0) 0 + have h01 := congrFun (congrFun hM 0) 1 + simp [Complex.ext_iff] at h00 h01 + obtain ⟨h0, h1⟩ := h01 + intro i + fin_cases i <;> assumption + +/-- The Pauli matrices `σ1`, `σ2`, `σ3` span the `su(2)` factor. -/ +lemma pauliSU2_span : ⊤ ≤ Submodule.span ℝ (Set.range pauliSU2) := by + refine (Submodule.top_le_span_range_iff_forall_exists_fun ℝ).mpr fun A => ?_ + refine ⟨pauliCoeff (A : Matrix (Fin 2) (Fin 2) ℂ), Subtype.ext ?_⟩ + rw [AddSubmonoidClass.coe_finsetSum] + simp only [SetLike.val_smul, coe_pauliSU2] + exact (eq_sum_pauliCoeff_smul A.2.1 A.2.2).symm + +/-- The Pauli basis of the `su(2)` factor of the gauge algebra. -/ +def su2Basis : Basis (Fin 3) ℝ + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 2) (Fin 2) ℂ) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 2) ℝ ℂ)) := + Basis.mk pauliSU2_linearIndependent pauliSU2_span + +@[simp] +lemma su2Basis_apply (i : Fin 3) : su2Basis i = pauliSU2 i := by + rw [su2Basis, Basis.mk_apply] + +/-! + +## E. The basis of the u(1) factor + +-/ + +/-- The unit `1` as the single basis element of the `u(1)` factor of the gauge + algebra. -/ +def u1One (_ : Fin 1) : selfAdjoint ℂ := 1 + +@[simp] +lemma coe_u1One (i : Fin 1) : (u1One i : ℂ) = 1 := rfl + +/-- The unit is linearly independent. -/ +lemma u1One_linearIndependent : LinearIndependent ℝ u1One := by + apply Fintype.linearIndependent_iff.mpr + intro g hg + have h : g 0 = 0 := by + simpa [u1One] using congrArg Subtype.val hg + intro i + rw [Subsingleton.elim i 0] + exact h + +/-- The unit spans the `u(1)` factor. -/ +lemma u1One_span : ⊤ ≤ Submodule.span ℝ (Set.range u1One) := by + refine (Submodule.top_le_span_range_iff_forall_exists_fun ℝ).mpr fun z => ?_ + refine ⟨fun _ => (z : ℂ).re, Subtype.ext ?_⟩ + have hz : (z : ℂ).im = 0 := Complex.conj_eq_iff_im.mp z.2 + simp [u1One, Complex.ext_iff, hz] + +/-- The basis of the `u(1)` factor of the gauge algebra. -/ +def u1Basis : Basis (Fin 1) ℝ (selfAdjoint ℂ) := + Basis.mk u1One_linearIndependent u1One_span + +@[simp] +lemma u1Basis_apply (i : Fin 1) : u1Basis i = 1 := by + rw [u1Basis, Basis.mk_apply, u1One] + +/-! + +## F. The standard basis of the gauge algebra + +-/ + +/-- The standard basis of the gauge algebra, indexed by `Fin 8 ⊕ Fin 3 ⊕ Fin 1`: the + eight Gell-Mann matrices on the `su(3)` factor, the three Pauli matrices `σ1`, `σ2`, + `σ3` on the `su(2)` factor, and `1` on the `u(1)` factor. -/ +def stdBasis : Basis (Fin 8 ⊕ Fin 3 ⊕ Fin 1) ℝ GaugeAlgebra := + su3Basis.prod (su2Basis.prod u1Basis) + +@[simp] +lemma stdBasis_inl_toSU3Matrix (k : Fin 8) : + (stdBasis (Sum.inl k)).toSU3Matrix = gellMannMatrix k := by + simp only [stdBasis, toSU3Matrix, Basis.prod_apply_inl_fst, su3Basis_apply, coe_gellMannSU3] + +@[simp] +lemma stdBasis_inl_toSU2Matrix (k : Fin 8) : + (stdBasis (Sum.inl k)).toSU2Matrix = 0 := by + simp only [stdBasis, toSU2Matrix, Basis.prod_apply_inl_snd, Prod.fst_zero, + ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inl_toU1Value (k : Fin 8) : + (stdBasis (Sum.inl k)).toU1Value = 0 := by + simp only [stdBasis, toU1Value, Basis.prod_apply_inl_snd, Prod.snd_zero, + ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inr_inl_toSU3Matrix (i : Fin 3) : + (stdBasis (Sum.inr (Sum.inl i))).toSU3Matrix = 0 := by + simp only [stdBasis, toSU3Matrix, Basis.prod_apply_inr_fst, ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inr_inl_toSU2Matrix (i : Fin 3) : + (stdBasis (Sum.inr (Sum.inl i))).toSU2Matrix = pauliMatrix (Sum.inr i) := by + simp only [stdBasis, toSU2Matrix, Basis.prod_apply_inr_snd, Basis.prod_apply_inl_fst, + su2Basis_apply, coe_pauliSU2] + +@[simp] +lemma stdBasis_inr_inl_toU1Value (i : Fin 3) : + (stdBasis (Sum.inr (Sum.inl i))).toU1Value = 0 := by + simp only [stdBasis, toU1Value, Basis.prod_apply_inr_snd, Basis.prod_apply_inl_snd, + ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inr_inr_toSU3Matrix (i : Fin 1) : + (stdBasis (Sum.inr (Sum.inr i))).toSU3Matrix = 0 := by + simp only [stdBasis, toSU3Matrix, Basis.prod_apply_inr_fst, ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inr_inr_toSU2Matrix (i : Fin 1) : + (stdBasis (Sum.inr (Sum.inr i))).toSU2Matrix = 0 := by + simp only [stdBasis, toSU2Matrix, Basis.prod_apply_inr_snd, Basis.prod_apply_inr_fst, + ZeroMemClass.coe_zero] + +@[simp] +lemma stdBasis_inr_inr_toU1Value (i : Fin 1) : + (stdBasis (Sum.inr (Sum.inr i))).toU1Value = 1 := by + simp only [stdBasis, toU1Value, Basis.prod_apply_inr_snd, u1Basis_apply, + selfAdjoint.val_one] + +/-! + +## G. The adjoint action in the standard basis + +In the standard basis the adjoint action of a gauge group element is the block-diagonal +matrix `adjointMatrix`: the `su(3)` and `su(2)` blocks pair the basis elements with +their conjugates through the trace, and the `u(1)` entry is `1`. + +-/ + +lemma toSU3Matrix_sum {ι : Type*} (s : Finset ι) (f : ι → GaugeAlgebra) : + (∑ x ∈ s, f x).toSU3Matrix = ∑ x ∈ s, (f x).toSU3Matrix := by + classical + induction s using Finset.cons_induction with + | empty => simp + | cons a s ha ih => rw [Finset.sum_cons, Finset.sum_cons, add_toSU3Matrix, ih] + +lemma toSU2Matrix_sum {ι : Type*} (s : Finset ι) (f : ι → GaugeAlgebra) : + (∑ x ∈ s, f x).toSU2Matrix = ∑ x ∈ s, (f x).toSU2Matrix := by + classical + induction s using Finset.cons_induction with + | empty => simp + | cons a s ha ih => rw [Finset.sum_cons, Finset.sum_cons, add_toSU2Matrix, ih] + +lemma toU1Value_sum {ι : Type*} (s : Finset ι) (f : ι → GaugeAlgebra) : + (∑ x ∈ s, f x).toU1Value = ∑ x ∈ s, (f x).toU1Value := by + classical + induction s using Finset.cons_induction with + | empty => simp + | cons a s ha ih => rw [Finset.sum_cons, Finset.sum_cons, add_toU1Value, ih] + +/-- The matrix of the adjoint action of a gauge group element in the standard basis: + block diagonal, with the `su(3)` and `su(2)` blocks the trace pairings + `2⁻¹ * (trace (T a * g T b g⁻¹)).re` of the basis elements with the conjugated basis + elements, `1` on the `u(1)` entry, and `0` between different factors. -/ +noncomputable def adjointMatrix (g : GaugeGroupI) : + Matrix (Fin 8 ⊕ Fin 3 ⊕ Fin 1) (Fin 8 ⊕ Fin 3 ⊕ Fin 1) ℝ := + Matrix.of fun a b => + match a, b with + | Sum.inl a, Sum.inl b => + 2⁻¹ * (Matrix.trace (gellMannMatrix a * + (g.toSU3.1 * gellMannMatrix b * star g.toSU3.1))).re + | Sum.inr (Sum.inl i), Sum.inr (Sum.inl j) => + 2⁻¹ * (Matrix.trace (pauliMatrix (Sum.inr i) * + (g.toSU2.1 * pauliMatrix (Sum.inr j) * star g.toSU2.1))).re + | Sum.inr (Sum.inr _), Sum.inr (Sum.inr _) => 1 + | _, _ => 0 + +@[simp] +lemma adjointMatrix_inl_inl (g : GaugeGroupI) (a b : Fin 8) : + adjointMatrix g (Sum.inl a) (Sum.inl b) + = 2⁻¹ * (Matrix.trace (gellMannMatrix a * + (g.toSU3.1 * gellMannMatrix b * star g.toSU3.1))).re := rfl + +@[simp] +lemma adjointMatrix_inl_inr (g : GaugeGroupI) (a : Fin 8) (x : Fin 3 ⊕ Fin 1) : + adjointMatrix g (Sum.inl a) (Sum.inr x) = 0 := by + cases x <;> rfl + +@[simp] +lemma adjointMatrix_inr_inl (g : GaugeGroupI) (x : Fin 3 ⊕ Fin 1) (b : Fin 8) : + adjointMatrix g (Sum.inr x) (Sum.inl b) = 0 := by + cases x <;> rfl + +@[simp] +lemma adjointMatrix_inr_inl_inr_inl (g : GaugeGroupI) (i j : Fin 3) : + adjointMatrix g (Sum.inr (Sum.inl i)) (Sum.inr (Sum.inl j)) + = 2⁻¹ * (Matrix.trace (pauliMatrix (Sum.inr i) * + (g.toSU2.1 * pauliMatrix (Sum.inr j) * star g.toSU2.1))).re := rfl + +@[simp] +lemma adjointMatrix_inr_inl_inr_inr (g : GaugeGroupI) (i : Fin 3) (u : Fin 1) : + adjointMatrix g (Sum.inr (Sum.inl i)) (Sum.inr (Sum.inr u)) = 0 := rfl + +@[simp] +lemma adjointMatrix_inr_inr_inr_inl (g : GaugeGroupI) (u : Fin 1) (j : Fin 3) : + adjointMatrix g (Sum.inr (Sum.inr u)) (Sum.inr (Sum.inl j)) = 0 := rfl + +@[simp] +lemma adjointMatrix_inr_inr_inr_inr (g : GaugeGroupI) (u v : Fin 1) : + adjointMatrix g (Sum.inr (Sum.inr u)) (Sum.inr (Sum.inr v)) = 1 := rfl + +/-- The adjoint action of the gauge group acts on the standard basis through + `adjointMatrix`. -/ +lemma adjoint_stdBasis (g : GaugeGroupI) (b : Fin 8 ⊕ Fin 3 ⊕ Fin 1) : + adjoint g (stdBasis b) = ∑ a, adjointMatrix g a b • stdBasis a := by + match b with + | Sum.inl k => + have hmem := conj_mem g.toSU3.2.1 (gellMannMatrix_selfAdjoint k) (gellMannMatrix_trace k) + refine ext_of_matrix ?_ ?_ ?_ + · rw [adjoint_toSU3Matrix, stdBasis_inl_toSU3Matrix, toSU3Matrix_sum] + simp only [smul_toSU3Matrix, Fintype.sum_sum_type, stdBasis_inl_toSU3Matrix, + stdBasis_inr_inl_toSU3Matrix, stdBasis_inr_inr_toSU3Matrix, smul_zero, + Finset.sum_const_zero, add_zero, adjointMatrix_inl_inl] + conv_lhs => rw [eq_sum_gellMannCoeff_smul hmem.1 hmem.2] + exact Finset.sum_congr rfl fun a _ => by + rw [gellMannCoeff_eq_trace hmem.1 hmem.2] + · rw [adjoint_toSU2Matrix, stdBasis_inl_toSU2Matrix, toSU2Matrix_sum] + simp [Fintype.sum_sum_type] + · rw [adjoint_toU1Value, stdBasis_inl_toU1Value, toU1Value_sum] + simp [Fintype.sum_sum_type] + | Sum.inr (Sum.inl j) => + have hmem := conj_mem g.toSU2.2.1 (pauliMatrix_inr_star j) (pauliMatrix_inr_trace j) + refine ext_of_matrix ?_ ?_ ?_ + · rw [adjoint_toSU3Matrix, stdBasis_inr_inl_toSU3Matrix, toSU3Matrix_sum] + simp [Fintype.sum_sum_type] + · rw [adjoint_toSU2Matrix, stdBasis_inr_inl_toSU2Matrix, toSU2Matrix_sum] + simp only [smul_toSU2Matrix, Fintype.sum_sum_type, stdBasis_inl_toSU2Matrix, + stdBasis_inr_inl_toSU2Matrix, stdBasis_inr_inr_toSU2Matrix, smul_zero, + Finset.sum_const_zero, zero_add, add_zero, adjointMatrix_inr_inl_inr_inl] + conv_lhs => rw [eq_sum_pauliCoeff_smul hmem.1 hmem.2] + exact Finset.sum_congr rfl fun i _ => by + rw [pauliCoeff_eq_trace hmem.1 hmem.2] + · rw [adjoint_toU1Value, stdBasis_inr_inl_toU1Value, toU1Value_sum] + simp [Fintype.sum_sum_type] + | Sum.inr (Sum.inr u) => + refine ext_of_matrix ?_ ?_ ?_ + · rw [adjoint_toSU3Matrix, stdBasis_inr_inr_toSU3Matrix, toSU3Matrix_sum] + simp [Fintype.sum_sum_type] + · rw [adjoint_toSU2Matrix, stdBasis_inr_inr_toSU2Matrix, toSU2Matrix_sum] + simp [Fintype.sum_sum_type] + · rw [adjoint_toU1Value, stdBasis_inr_inr_toU1Value, toU1Value_sum] + simp [Fintype.sum_sum_type] + +/-- The matrix of the adjoint action in the standard basis is `adjointMatrix`. -/ +lemma toMatrix_adjoint (g : GaugeGroupI) : + LinearMap.toMatrix stdBasis stdBasis (adjoint g) = adjointMatrix g := by + ext a b + rw [LinearMap.toMatrix_apply, adjoint_stdBasis g b] + exact congrFun (stdBasis.repr_sum_self _) a + +/-- The action of `adjointMatrix` on coordinates in the standard basis corresponds to + the adjoint action of the gauge group on the gauge algebra. -/ +lemma adjointMatrix_mulVec_repr (g : GaugeGroupI) (a : GaugeAlgebra) : + (adjointMatrix g).mulVec (stdBasis.repr a) = ⇑(stdBasis.repr (adjoint g a)) := by + rw [← toMatrix_adjoint] + exact LinearMap.toMatrix_mulVec_repr stdBasis stdBasis (adjoint g) a + +/-- The dual adjoint action on the dual standard basis: the coordinate functions + transform through the rows of `adjointMatrix`. -/ +lemma adjoint_dualMap_coord (g : GaugeGroupI) (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) : + (adjoint g).dualMap (stdBasis.coord a) + = ∑ b, adjointMatrix g a b • stdBasis.coord b := by + refine LinearMap.ext fun x => ?_ + have h := congrFun (adjointMatrix_mulVec_repr g x) a + simp only [LinearMap.dualMap_apply, Basis.coord_apply, LinearMap.sum_apply, + LinearMap.smul_apply, smul_eq_mul] + rw [← h] + simp [Matrix.mulVec, dotProduct] + +end GaugeAlgebra + +end + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeAlgebra/InfinitesimalAction.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/InfinitesimalAction.lean new file mode 100644 index 000000000..665caa967 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/InfinitesimalAction.lean @@ -0,0 +1,550 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Truncation +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv +/-! +# The infinitesimal action underlying a matter representation + +## i. Overview + +The covariant derivative `∇_ρ F = [∂_ρ F] + A_ρ · F` of a matter family is built from +an action `act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V` of the gauge algebra on the value +space. For the covariant derivative to transform covariantly, `act` must be the +*infinitesimal action* underlying the representation `rep` of the jet gauge group in +which the family transforms — the physicists' statement that the matrices `i dρ(T^a)` +generate `ρ`. This file packages that compatibility as the structure +`IsInfinitesimalActionOf`, and proves the theorem it exists for: the covariant +derivative preserves the gauge tensors, `TransformsIn.covDerivAction`. + +## ii. Key results + +- `GaugeAlgebra.IsInfinitesimalActionOf` : `act` is the infinitesimal action underlying + `rep`. +- `TransformsIn.covDerivAction` : the covariant derivative preserves `TransformsIn`. + +## iii. Table of contents + +- A. The infinitesimal action underlying a representation +- B. The covariant derivative preserves `TransformsIn` +- C. The conjugate action and the conjugate representation + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +namespace GaugeAlgebra + +open IsGaugeField + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-! + +## A. The infinitesimal action underlying a representation + +-/ + +/-- `act` is the *infinitesimal action* of the gauge algebra underlying the + representation `rep` of the jet gauge group, when the base-point Taylor + coefficients of `rep` satisfy the two laws forced by `rep` being generated by + `act`: + + * `repCoeff_cons` — the Leibniz rule in the Maurer–Cartan form: differentiating + the representation once produces minus the action of the Maurer–Cartan form, + with the remaining derivatives distributed over the antidiagonal (for the + adjoint representation this is `adjointDualCoeff_cons`); + * `repCoeff_act` — the transports of `rep` intertwine `act` with the adjoint + transports, as an antidiagonal convolution (for the adjoint representation this + is `adjointTransport_bracket`); at `x = 0` it is the classical equivariance + `rep(U)|₀ ∘ act c = act (Ad(U) c)|₀ ∘ rep(U)|₀`. + + These are exactly the identities consumed by the proof that the covariant + derivative `covDerivAction` preserves `TransformsIn`. -/ +structure IsInfinitesimalActionOf (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) : Prop where + repCoeff_cons : ∀ (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)), + repCoeff rep U (μ ::ₘ x) = + -((x.antidiagonal.map fun p => + act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) ∘ₗ repCoeff rep U p.2).sum) + repCoeff_act : ∀ (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) + (c : GaugeAlgebra), + repCoeff rep U x ∘ₗ act c = + ((x.antidiagonal.map fun p => + act (adjointCoeff U p.1 c) ∘ₗ repCoeff rep U p.2).sum) + +/-- The dual form of the Leibniz law: the once-more-derived dual coefficient is + minus the antidiagonal convolution of dual coefficients against `act` of the + derived Maurer–Cartan form — the analogue of `adjointDualCoeff_cons`. -/ +lemma IsInfinitesimalActionOf.repDualCoeff_cons + {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} + {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} + (h : IsInfinitesimalActionOf act rep) (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + repDualCoeff rep U (μ ::ₘ x) φ = + -((x.antidiagonal.map fun p => + repDualCoeff rep U p.2 (φ ∘ₗ act (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U μ))))).sum) := by + refine LinearMap.ext fun v => ?_ + have h1 := LinearMap.congr_fun (h.repCoeff_cons U μ x) v + simp only [LinearMap.neg_apply, Multiset.sum_linearMap_apply, Multiset.map_map, + Function.comp_apply, LinearMap.coe_comp] at h1 + simp only [repDualCoeff, LinearMap.dualMap_apply, LinearMap.neg_apply, + Multiset.sum_linearMap_apply, Multiset.map_map, Function.comp_apply, + LinearMap.coe_comp] + rw [h1, map_neg, map_multiset_sum, Multiset.map_map] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => rfl)) + +/-! + +## B. The covariant derivative preserves `TransformsIn` + +-/ + +section MatterCovariance + +variable {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} +variable {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} +variable [FiniteDimensional ℂ V] + +/-- The action of families against the dual representation coefficients: the + antidiagonal convolution mixing the adjoint transport on the field slot with the + representation transport on the matter slot — the family-level form of + `IsInfinitesimalActionOf.repCoeff_act`, and the analogue of + `bracketFam_adjointDualCoeff`. -/ +lemma IsInfinitesimalActionOf.actionFam_repDualCoeff + (h : IsInfinitesimalActionOf act rep) (U : JetGaugeGroupI) + (x : Multiset (Fin 1 ⊕ Fin 3)) (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (g : Module.Dual ℂ V →ₗ[ℂ] B) (φ : Module.Dual ℂ V) : + actionFam act f g (repDualCoeff rep U x φ) = + (x.antidiagonal.map fun p => + actionFam act (f ∘ₗ adjointDualCoeff U p.1) + (g ∘ₗ repDualCoeff rep U p.2) φ).sum := by + have hT : ∀ (c : GaugeAlgebra) (v : V), repCoeff rep U x (act c v) = + (x.antidiagonal.map fun p => + act (adjointCoeff U p.1 c) (repCoeff rep U p.2 v)).sum := by + intro c v + have h1 := LinearMap.congr_fun (h.repCoeff_act U x c) v + simpa [Multiset.sum_linearMap_apply, Multiset.map_map, LinearMap.coe_comp, + Function.comp_apply] using h1 + rw [show repDualCoeff rep U x = (repCoeff rep U x).dualMap from rfl, + show actionFam act f g ((repCoeff rep U x).dualMap φ) = + dualPairEquivC ((TensorProduct.map LinearMap.id (repCoeff rep U x)) + (tensorAction act (dualPairEquiv.symm f) (dualPairEquivC.symm g))) φ from + (dualPairEquivC_map_right (repCoeff rep U x) _ φ).symm, + ← tensorAction_map_right_antidiagonal act (adjointCoeff U) (repCoeff rep U) x hT, + map_multiset_sum, Multiset.map_map, Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + simp only [Function.comp_apply] + rw [← symm_comp_right, ← symm_comp_right_C] + rfl + +omit [FiniteDimensional ℂ V] in +/-- If `F` transforms in `rep`, so do its `κ ::ₘ s`-derived symbols, with the extra + derivative traced through `IsInfinitesimalActionOf.repDualCoeff_cons`: the Leibniz + splittings where `κ` stays a derivative, minus the convolution where `κ` hits the + representation — `act` of the derived Maurer–Cartan form. -/ +lemma _root_.StandardModel.TransformsIn.repGauge_cons + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf act rep) + (U : JetGaugeGroupI) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V) : + repGauge U (F (κ ::ₘ s) φ) = + (s.antidiagonal.map fun p => + F (κ ::ₘ p.2) (repDualCoeff rep U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (repDualCoeff rep U⁻¹ q.2 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ κ)))))).sum).sum := by + rw [hF U φ (κ ::ₘ s)] + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + have hsec : (Multiset.map (fun p => + F p.2 (repDualCoeff rep U⁻¹ (κ ::ₘ p.1) φ)) s.antidiagonal).sum = + -(s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (repDualCoeff rep U⁻¹ q.2 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ κ)))))).sum).sum := by + rw [← Multiset.sum_map_neg''] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [hact.repDualCoeff_cons U⁻¹ κ p.1 φ, map_neg, map_multiset_sum, Multiset.map_map] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => rfl)) + rw [hsec, sub_eq_add_neg] + +set_option maxHeartbeats 2000000 in +/-- The all-orders gauge transformation of the derived action `A_ρ · F` for `F` + transforming in `rep`: since `F` transforms homogeneously, only one cross-term + convolution through `act` survives — the analogue of + `TransformsInAdjoint.repGauge_bracketFamConv` with a matter field in the second + slot. -/ +lemma _root_.StandardModel.TransformsIn.repGauge_actionFamConv + (hA : IsGaugeField repLorentz repGauge A) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf act rep) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ V) : + repGauge U (actionFamConv A act ρ F s φ) = + (s.antidiagonal.map fun p => + actionFamConv A act ρ F p.2 (repDualCoeff rep U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (repDualCoeff rep U⁻¹ r.1 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum := by + have hAlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ GaugeAlgebra), + repGauge U (A u ρ ψ) = + ((u.antidiagonal.map fun q => A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv u (maurerCartanForm U⁻¹ ρ)))) := by + intro u ψ + rw [hA.gauge_apply_deriv U u ρ ψ, Multiset.sum_linearMap_apply, Multiset.map_map] + congr 1 + have hFlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℂ V), + repGauge U (F u ψ) = + ((u.antidiagonal.map fun r => F r.2 ∘ₗ repDualCoeff rep U⁻¹ r.1).sum) ψ := by + intro u ψ + rw [hF U ψ u, Multiset.sum_linearMap_apply, Multiset.map_map] + congr 1 + have hMa : (s.antidiagonal.map fun p => + actionFam act ((p.1.antidiagonal.map fun q => + A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) + ((p.2.antidiagonal.map fun r => + F r.2 ∘ₗ repDualCoeff rep U⁻¹ r.1).sum) φ).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + actionFam act (A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ repDualCoeff rep U⁻¹ r.1) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [actionFam_sum_left, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_) + simp only [Function.comp_apply] + rw [actionFam_sum_right, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply] + have hMc : (s.antidiagonal.map fun p => + actionFamConv A act ρ F p.2 (repDualCoeff rep U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + actionFam act (A r.1 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ repDualCoeff rep U⁻¹ q.2) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_congr rfl (fun r hr => by + rw [Function.comp_apply, + hact.actionFam_repDualCoeff U⁻¹ p.1 (A r.1 ρ) (F r.2) φ]), + Multiset.sum_map_sum_map] + have hM := hMa.trans ((Multiset.sum_antidiagonal_exchange s fun a b c d => + actionFam act (A b ρ ∘ₗ adjointDualCoeff U⁻¹ a) + (F d ∘ₗ repDualCoeff rep U⁻¹ c) φ).trans hMc.symm) + have hCg : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + ((p.2.antidiagonal.map fun r => F r.2 ∘ₗ repDualCoeff rep U⁻¹ r.1).sum) + (φ ∘ₗ act (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ ρ)))) = + (p.2.antidiagonal.map fun r => + F r.2 (repDualCoeff rep U⁻¹ r.1 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ ρ)))))).sum := by + intro p + rw [Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply, LinearMap.coe_comp] + rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, map_multiset_sum, + Multiset.map_map, + Multiset.map_congr rfl (fun p hp => by + rw [Function.comp_apply, Function.comp_apply, + repGauge_actionFam hA U (hAlaw p.1) (hFlaw p.2) φ, hCg p]), + Multiset.sum_map_add, hM] + +set_option maxHeartbeats 2000000 in +/-- **The covariant derivative preserves `TransformsIn`**: if `F` transforms in the + representation `rep` and `act` is the infinitesimal action underlying `rep`, then + `∇_ρ F = [∂_ρ F] + A_ρ · F` transforms in `rep`. The single inhomogeneous + convolution of `[∂_{ρ ::ₘ s} F]` cancels the single `act` cross-term convolution of + `A_ρ · F` through the coassociativity of the antidiagonal — the matter-field + analogue of `TransformsInAdjoint.covDerivAdjoint`. -/ +theorem _root_.StandardModel.TransformsIn.covDerivAction + (hA : IsGaugeField repLorentz repGauge A) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf act rep) (ρ : Fin 1 ⊕ Fin 3) : + TransformsIn repGauge rep (IsGaugeField.covDerivAction A act F ρ) := by + intro U φ s + have hL : repGauge U (IsGaugeField.covDerivAction A act F ρ s φ) = + repGauge U (F (ρ ::ₘ s) φ) + repGauge U (actionFamConv A act ρ F s φ) := by + rw [covDerivAction_apply, map_add] + have hR : (s.antidiagonal.map fun p => + IsGaugeField.covDerivAction A act F ρ p.2 (repDualCoeff rep U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + F (ρ ::ₘ p.2) (repDualCoeff rep U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + actionFamConv A act ρ F p.2 (repDualCoeff rep U⁻¹ p.1 φ)).sum := by + rw [← Multiset.sum_map_add] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [covDerivAction_apply] + have hcancel : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (repDualCoeff rep U⁻¹ q.2 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (repDualCoeff rep U⁻¹ r.1 + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + F c (repDualCoeff rep U⁻¹ b + (φ ∘ₗ act (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv a + (maurerCartanForm U⁻¹ ρ)))))) + rw [hL, hF.repGauge_cons hact U ρ s φ, hF.repGauge_actionFamConv hA hact U s ρ φ, + hR, hcancel] + abel + +/-- **Every iterated covariant derivative preserves `TransformsIn`**: if `F` transforms + in `rep` and `act` is the infinitesimal action underlying `rep`, then + `∇_{l 0} ⋯ ∇_{l (n-1)} F` transforms in `rep` — the recursion of + `TransformsIn.covDerivAction` over the tuple of directions. -/ +theorem _root_.StandardModel.TransformsIn.covDerivIter + (hA : IsGaugeField repLorentz repGauge A) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hact : IsInfinitesimalActionOf act rep) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repGauge rep (IsGaugeField.covDerivIter A act F n l) := by + induction n with + | zero => exact hF + | succ n ih => + exact TransformsIn.covDerivAction hA (ih fun i => l i.succ) hact (l 0) + +omit [FiniteDimensional ℂ V] in +/-- **Matter gauge tensors whose zeroth representation coefficient is trivial on pure + jets are fixed by pure jets**: for a family transforming in `rep`, a gauge jet with + trivial base-point value acts trivially on the underived symbol, provided the + representation's zeroth Taylor coefficient is the identity on such jets. -/ +lemma _root_.StandardModel.TransformsIn.repGauge_eq_of_mem_truncationKer_zero + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B} + (hF : TransformsIn repGauge rep F) + (hrep : ∀ {W : JetGaugeGroupI}, W.eval = 1 → repCoeff rep W 0 = LinearMap.id) + (U : JetGaugeGroupI.truncationKer 0) (φ : Module.Dual ℂ V) : + repGauge U.1 (F 0 φ) = F 0 φ := by + have hinv : ((U.1)⁻¹).eval = 1 := by + rw [map_inv, JetGaugeGroupI.mem_truncationKer_zero_iff.mp U.2, inv_one] + have h1 := hF U.1 φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + rw [h1, show repDualCoeff rep (U.1)⁻¹ 0 = (repCoeff rep (U.1)⁻¹ 0).dualMap from rfl, + hrep hinv] + rfl + +end MatterCovariance + +/-! + +## C. The conjugate action and the conjugate representation + +-/ + +section ConjugateAction + +/-- A linear endomorphism read on the conjugate module: the same underlying map, + through the identity `conjEquiv`. Conjugating twists nothing at the level of the + additive group, so all structural identities (`comp`, `add`, `neg`, sums) hold + definitionally. -/ +def _root_.ConjModule.endConj {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] (f : M →ₗ[k] M) : + ConjModule M →ₗ[k] ConjModule M where + toFun v := conjEquiv (k := k) (M := M) (f ((conjEquiv (k := k) (M := M)).symm v)) + map_add' v w := f.map_add v w + map_smul' a v := f.map_smul (star a) v + +@[simp] +lemma _root_.ConjModule.endConj_apply {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] (f : M →ₗ[k] M) (v : ConjModule M) : + ConjModule.endConj f v = + conjEquiv (k := k) (M := M) (f ((conjEquiv (k := k) (M := M)).symm v)) := rfl + +lemma _root_.ConjModule.endConj_id {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] : + ConjModule.endConj (LinearMap.id : M →ₗ[k] M) = LinearMap.id := rfl + +lemma _root_.ConjModule.endConj_comp {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] (f g : M →ₗ[k] M) : + ConjModule.endConj (f ∘ₗ g) = ConjModule.endConj f ∘ₗ ConjModule.endConj g := rfl + +lemma _root_.ConjModule.endConj_add {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] (f g : M →ₗ[k] M) : + ConjModule.endConj (f + g) = ConjModule.endConj f + ConjModule.endConj g := rfl + +lemma _root_.ConjModule.endConj_neg {k : Type*} [CommRing k] [StarRing k] {M : Type*} + [AddCommGroup M] [Module k M] (f : M →ₗ[k] M) : + ConjModule.endConj (-f) = -ConjModule.endConj f := rfl + +lemma _root_.ConjModule.endConj_multiset_sum {k : Type*} [CommRing k] [StarRing k] + {M : Type*} [AddCommGroup M] [Module k M] (S : Multiset (M →ₗ[k] M)) : + ConjModule.endConj S.sum = (S.map ConjModule.endConj).sum := by + induction S using Multiset.induction_on with + | empty => rfl + | cons f S ih => + rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + ConjModule.endConj_add, ih] + +/-- Conjugation of endomorphisms commutes with real scalars: the star on the + conjugated complex scalar is invisible on the reals. -/ +lemma _root_.ConjModule.endConj_real_smul {M : Type*} [AddCommGroup M] [Module ℂ M] + (r : ℝ) (f : M →ₗ[ℂ] M) : + ConjModule.endConj (r • f) = r • ConjModule.endConj f := by + refine LinearMap.ext fun v => ?_ + show (algebraMap ℝ ℂ r) • (f ((conjEquiv (k := ℂ) (M := M)).symm v)) + = (starRingEnd ℂ) (algebraMap ℝ ℂ r) • (f ((conjEquiv (k := ℂ) (M := M)).symm v)) + rw [show (starRingEnd ℂ) (algebraMap ℝ ℂ r) = algebraMap ℝ ℂ r from + Complex.conj_ofReal r] + +/-- **The conjugate of an infinitesimal action**: the same maps, read on the conjugate + module — the generators of the conjugate representation. -/ +noncomputable def actionConj (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) : + GaugeAlgebra →ₗ[ℝ] ConjModule V →ₗ[ℂ] ConjModule V where + toFun c := ConjModule.endConj (act c) + map_add' c₁ c₂ := by rw [map_add, ConjModule.endConj_add] + map_smul' r c := by rw [map_smul, ConjModule.endConj_real_smul, RingHom.id_apply] + +@[simp] +lemma actionConj_apply (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (c : GaugeAlgebra) : + actionConj act c = ConjModule.endConj (act c) := rfl + +/-- The identification of the jets of a conjugate field with the conjugates of the + jets: conjugation is monoidal, and the star of the jet-ring factor absorbs the + twist — `conj (g ⊗ u) ↦ star g ⊗ conj u`. This is the equivalence along which + `repConj` carries the conjugated representation. -/ +noncomputable def conjJetEquiv : + ConjModule (JetRing ⊗[ℂ] V) ≃ₗ[ℂ] JetRing ⊗[ℂ] ConjModule V := + (ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V))) + +lemma conjJetEquiv_conjEquiv_tmul (g : JetRing) (u : V) : + conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (g ⊗ₜ[ℂ] u)) + = star g ⊗ₜ[ℂ] conjEquiv (k := ℂ) (M := V) u := by + rw [conjJetEquiv, LinearEquiv.trans_apply, ConjModule.tensorEquiv_symm_conjEquiv_tmul, + TensorProduct.congr_tmul, JetRing.starConjEquiv_apply, LinearEquiv.refl_apply, + LinearEquiv.symm_apply_apply] + +section ConjRep + +variable {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} +variable {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} + +/-- The conjugate representation acts through `conjJetEquiv` by the original maps. -/ +lemma repConj_conjJetEquiv (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (U : JetGaugeGroupI) (w : JetRing ⊗[ℂ] V) : + repConj rep U (conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (rep U w)) := by + show conjJetEquiv ((rep.conj U) (conjJetEquiv.symm + (conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)))) = _ + rw [LinearEquiv.symm_apply_apply, Representation.conj_apply, + LinearEquiv.symm_apply_apply] + +/-- **The base-point Taylor coefficients of the conjugate representation are the + conjugated coefficients**: the derivative directions are real, so conjugation passes + through `∂_x` and the base-point evaluation untouched. -/ +lemma repCoeff_repConj (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + repCoeff (repConj rep) U x = ConjModule.endConj (repCoeff rep U x) := by + have hE_tmul := conjJetEquiv_conjEquiv_tmul (V := V) + -- conjugation intertwines the formal derivative + have hderiv1 : ∀ (μ : Fin 1 ⊕ Fin 3) (w : JetRing ⊗[ℂ] V), + jetDeriv μ (conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (jetDeriv μ w)) := by + intro μ w + induction w using TensorProduct.induction_on with + | zero => simp + | tmul g u => + rw [hE_tmul, jetDeriv_tmul, jetDeriv_tmul, hE_tmul, JetRing.pderiv_star] + | add a b ha hb => + rw [map_add, map_add, map_add, ha, hb, map_add, map_add, map_add] + have hderiv : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (w : JetRing ⊗[ℂ] V), + jetIteratedDeriv s (conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)) + = conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) + (jetIteratedDeriv s w)) := by + intro s + induction s using Multiset.induction_on with + | empty => intro w; rw [jetIteratedDeriv_zero]; rfl + | cons μ t ih => + intro w + rw [jetIteratedDeriv_cons, LinearMap.comp_apply, ih, hderiv1, + jetIteratedDeriv_cons, LinearMap.comp_apply] + -- conjugation intertwines the base-point evaluation + have heval : ∀ w : JetRing ⊗[ℂ] V, + jetEval (conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)) + = conjEquiv (k := ℂ) (M := V) (jetEval w) := by + intro w + induction w using TensorProduct.induction_on with + | zero => simp + | tmul g u => + rw [hE_tmul, jetEval_tmul, jetEval_tmul, JetRing.constantCoeff_star, + map_smulₛₗ, starRingEnd_apply] + | add a b ha hb => rw [map_add, map_add, map_add, ha, hb, map_add, map_add] + refine LinearMap.ext fun v => ?_ + have hv : jetOfConstant v = conjJetEquiv (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) + (jetOfConstant ((conjEquiv (k := ℂ) (M := V)).symm v))) := by + rw [jetOfConstant_apply, jetOfConstant_apply, hE_tmul, star_one, + LinearEquiv.apply_symm_apply] + show jetEval (jetIteratedDeriv x (repConj rep U (jetOfConstant v))) = _ + rw [hv, repConj_conjJetEquiv, hderiv, heval] + rfl + +/-- The base-point triviality of the zeroth Taylor coefficient passes to the + conjugate representation. -/ +lemma repCoeff_repConj_zero_eq_id {W : JetGaugeGroupI} + (hrep : repCoeff rep W 0 = LinearMap.id) : + repCoeff (repConj rep) W 0 = LinearMap.id := by + rw [repCoeff_repConj, hrep, ConjModule.endConj_id] + +/-- **The conjugate of an infinitesimal action underlies the conjugate + representation**: conjugating the Taylor coefficients preserves both the + Maurer–Cartan Leibniz law and the adjoint intertwining, since the gauge-algebra + inputs are real. -/ +theorem IsInfinitesimalActionOf.conj (h : IsInfinitesimalActionOf act rep) : + IsInfinitesimalActionOf (actionConj act) (repConj rep) := by + constructor + · intro U μ x + rw [repCoeff_repConj, h.repCoeff_cons U μ x, ConjModule.endConj_neg, + ConjModule.endConj_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum + (Multiset.map_congr rfl fun p hp => ?_)) + rw [Function.comp_apply, ConjModule.endConj_comp, repCoeff_repConj] + rfl + · intro U x c + rw [repCoeff_repConj, show actionConj act c = ConjModule.endConj (act c) from rfl, + ← ConjModule.endConj_comp, h.repCoeff_act U x c, + ConjModule.endConj_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, ConjModule.endConj_comp, repCoeff_repConj] + rfl + +end ConjRep + +end ConjugateAction + +end GaugeAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean b/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean new file mode 100644 index 000000000..d5ee00574 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean @@ -0,0 +1,868 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +public import Mathlib.Analysis.Normed.Algebra.Exponential +public import Mathlib.RingTheory.MvPowerSeries.PiTopology +public import Mathlib.Topology.Instances.Matrix +public import Mathlib.RingTheory.PowerSeries.Derivative +public import Mathlib.RingTheory.PowerSeries.Basic +/-! +# The jet gauge algebra + +We define `JetGaugeAlgebra` as the Lie algebra of `JetGaugeGroupI`, +defined explicitly as traceless self-adjoint matrices, and giving it an instance `LieAlgebra`. +This is a matrix Lie algebra, so the bracket is given by the commutator of matrices. + +Note here that `JetGaugeAlgebra` is a module over `ℝ` not `ℂ` or `JetRing`. + +On this Lie algebra define a prefered basis, `basis`, indexed by +`basisIndex × Multiset (Fin 1 ⊕ Fin 3)`. +Here `basisIndex` is the sum `Fin 8 ⊕ Fin 3 ⊕ Fin 1`. The first factor +corresponds to the Gell-Mann matrices which form a basis of `su(3)`, +the second factor corresponds to the Pauli matrices which form a basis of `su(2)`, +and the third factor corresponds to the identity matrix which forms a basis of `u(1)`. + +We let `structuralConstant` (typically called `f`) be the structure constants of the Lie algebra +with respect to this prefered basis, so that +``` + [basis i, basis j] = i * ∑ k, structuralConstant i j k • basis k +``` + +On `JetGaugeAlgebra` we define the adjoint representation of `JetGaugeGroupI`, +`adjointRep`, which acts via `x ↦ g * x * g⁻¹`. + +There is also a derivative `deriv : Fin 1 ⊕ Fin 3 → JetLieAlgebra →ₗ[ℝ] JetLieAlgebra` +whose action can be defined componentwise in terms of the basis. + +The derivative acts on brackets via the Leibniz rule: +``` + deriv μ [x, y] = [deriv μ x, y] + [x, deriv μ y] +``` + +-/ + +@[expose] public section +TODO "Make the API here match what is in the doc-string." +TODO "Add discussion about the basis." +namespace StandardModel +open MvPowerSeries Matrix + +/-- The jet gauge algebra: the Lie-algebra analogue of `JetGaugeGroupI`, with one factor per + gauge group factor — traceless self-adjoint `3 × 3` and `2 × 2` matrices and a self-adjoint + scalar, all with coefficients in the ring `JetRing` of formal power series in the spacetime + coordinates. The Maurer–Cartan forms of the jet gauge group are valued here, hermiticity + being `star_maurerCartanSU3` and its companions. -/ +abbrev JetGaugeAlgebra := + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 3) (Fin 3) JetRing) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 3) ℝ JetRing)) × + ↥(selfAdjoint.submodule ℝ (Matrix (Fin 2) (Fin 2) JetRing) ⊓ + LinearMap.ker (Matrix.traceLinearMap (Fin 2) ℝ JetRing)) × + selfAdjoint JetRing + +namespace JetGaugeAlgebra + +/-! + +## Basic projections + +-/ + +/-- The `su(3)`-factor component of an element of the jet gauge algebra. -/ +def toSU3Matrix (a : JetGaugeAlgebra) : Matrix (Fin 3) (Fin 3) JetRing := a.1 + +/-- The `su(2)`-factor component of an element of the jet gauge algebra. -/ +def toSU2Matrix (a : JetGaugeAlgebra) : Matrix (Fin 2) (Fin 2) JetRing := a.2.1 + +/-- The `u(1)`-factor component of an element of the jet gauge algebra. -/ +def toU1Value (a : JetGaugeAlgebra) : JetRing := a.2.2 + +/-- The underlying matrix value of an element of the jet gauge algebra, as a + product of matrices. -/ +def toVal (a : JetGaugeAlgebra) : + Matrix (Fin 3) (Fin 3) JetRing × Matrix (Fin 2) (Fin 2) JetRing × JetRing := + (a.toSU3Matrix, a.toSU2Matrix, a.toU1Value) + +@[simp] +lemma toVal_fst (a : JetGaugeAlgebra) : a.toVal.1 = a.toSU3Matrix := rfl + +@[simp] +lemma toVal_snd_fst (a : JetGaugeAlgebra) : a.toVal.2.1 = a.toSU2Matrix := rfl + +@[simp] +lemma toVal_snd_snd (a : JetGaugeAlgebra) : a.toVal.2.2 = a.toU1Value := rfl + +@[ext] +lemma ext_of_matrix {a b : JetGaugeAlgebra} (h1 : a.toSU3Matrix = b.toSU3Matrix) + (h2 : a.toSU2Matrix = b.toSU2Matrix) (h3 : a.toU1Value = b.toU1Value) : a = b := by + cases a; cases b + simp only [toSU3Matrix, toSU2Matrix, toU1Value] at h1 h2 h3 + grind + +/-! + +## Constructor from a product of matrices + +-/ + +def ofMatrixProd (A : Matrix (Fin 3) (Fin 3) JetRing × + Matrix (Fin 2) (Fin 2) JetRing × JetRing) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : JetGaugeAlgebra := + ⟨⟨A.1, hA⟩, ⟨A.2.1, hB⟩, ⟨A.2.2, hC⟩⟩ + +@[simp] +lemma ofMatrixProd_toSU3Matrix (A : Matrix (Fin 3) (Fin 3) JetRing × + Matrix (Fin 2) (Fin 2) JetRing × JetRing) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toSU3Matrix = A.1 := by rfl + +@[simp] +lemma ofMatrixProd_toSU2Matrix (A : Matrix (Fin 3) (Fin 3) JetRing × + Matrix (Fin 2) (Fin 2) JetRing × JetRing) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toSU2Matrix = A.2.1 := by rfl + +@[simp] +lemma ofMatrixProd_toU1Value (A : Matrix (Fin 3) (Fin 3) JetRing × + Matrix (Fin 2) (Fin 2) JetRing × JetRing) (hA : star A.1 = A.1 ∧ A.1.trace = 0) + (hB : star A.2.1 = A.2.1 ∧ A.2.1.trace = 0) (hC : star A.2.2 = A.2.2) : + (ofMatrixProd A hA hB hC).toU1Value = A.2.2 := by rfl + +/-! + +## The Lie algebra instance + +-/ + +@[simp] +lemma add_toSU3Matrix (a b : JetGaugeAlgebra) : + (a + b).toSU3Matrix = a.toSU3Matrix + b.toSU3Matrix := by rfl + +@[simp] +lemma add_toSU2Matrix (a b : JetGaugeAlgebra) : + (a + b).toSU2Matrix = a.toSU2Matrix + b.toSU2Matrix := by rfl + +@[simp] +lemma add_toU1Value (a b : JetGaugeAlgebra) : + (a + b).toU1Value = a.toU1Value + b.toU1Value := by rfl + +@[simp] +lemma zero_toSU3Matrix : (0 : JetGaugeAlgebra).toSU3Matrix = 0 := by rfl + +@[simp] +lemma zero_toSU2Matrix : (0 : JetGaugeAlgebra).toSU2Matrix = 0 := by rfl + +@[simp] +lemma zero_toU1Value : (0 : JetGaugeAlgebra).toU1Value = 0 := by rfl + +@[simp] +lemma smul_toSU3Matrix (r : ℝ) (a : JetGaugeAlgebra) : + (r • a).toSU3Matrix = r • a.toSU3Matrix := by rfl + +@[simp] +lemma smul_toSU2Matrix (r : ℝ) (a : JetGaugeAlgebra) : + (r • a).toSU2Matrix = r • a.toSU2Matrix := by rfl + +@[simp] +lemma smul_toU1Value (r : ℝ) (a : JetGaugeAlgebra) : + (r • a).toU1Value = r • a.toU1Value := by rfl + +@[simp] +lemma sub_toSU3Matrix (a b : JetGaugeAlgebra) : + (a - b).toSU3Matrix = a.toSU3Matrix - b.toSU3Matrix := by rfl + +@[simp] +lemma sub_toSU2Matrix (a b : JetGaugeAlgebra) : + (a - b).toSU2Matrix = a.toSU2Matrix - b.toSU2Matrix := by rfl + +@[simp] +lemma sub_toU1Value (a b : JetGaugeAlgebra) : + (a - b).toU1Value = a.toU1Value - b.toU1Value := by rfl + +/-- The bracket on the jet gauge algebra: `I` times the matrix commutator on the + `su(3)` and `su(2)` factors, and zero on the (commutative) `u(1)` factor. The + factor of `I` is what makes the bracket of two hermitian matrices hermitian + again; it is also why the bracket is only `ℝ`-bilinear, not `ℂ`-bilinear. -/ +noncomputable instance : Bracket JetGaugeAlgebra JetGaugeAlgebra where + bracket a b := ofMatrixProd + (Complex.I • (a.toSU3Matrix * b.toSU3Matrix - b.toSU3Matrix * a.toSU3Matrix), + Complex.I • (a.toSU2Matrix * b.toSU2Matrix - b.toSU2Matrix * a.toSU2Matrix), + 0) + ⟨by + rw [star_smul, star_sub, star_mul, star_mul, + show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1, + show star b.toSU3Matrix = b.toSU3Matrix from b.1.2.1, + Complex.star_def, Complex.conj_I, neg_smul, ← smul_neg, neg_sub], + by rw [Matrix.trace_smul, Matrix.trace_sub, Matrix.trace_mul_comm, sub_self, smul_zero]⟩ + ⟨by + rw [star_smul, star_sub, star_mul, star_mul, + show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1, + show star b.toSU2Matrix = b.toSU2Matrix from b.2.1.2.1, + Complex.star_def, Complex.conj_I, neg_smul, ← smul_neg, neg_sub], + by rw [Matrix.trace_smul, Matrix.trace_sub, Matrix.trace_mul_comm, sub_self, smul_zero]⟩ + (star_zero _) + +@[simp] +lemma bracket_toSU3Matrix (a b : JetGaugeAlgebra) : + ⁅a, b⁆.toSU3Matrix = + Complex.I • (a.toSU3Matrix * b.toSU3Matrix - b.toSU3Matrix * a.toSU3Matrix) := rfl + +@[simp] +lemma bracket_toSU2Matrix (a b : JetGaugeAlgebra) : + ⁅a, b⁆.toSU2Matrix = + Complex.I • (a.toSU2Matrix * b.toSU2Matrix - b.toSU2Matrix * a.toSU2Matrix) := rfl + +@[simp] +lemma bracket_toU1Value (a b : JetGaugeAlgebra) : + ⁅a, b⁆.toU1Value = 0 := rfl + +noncomputable instance : LieRing JetGaugeAlgebra where + add_lie a b c := by + ext <;> simp [add_mul, mul_add, smul_add, smul_sub] <;> abel + lie_add a b c := by + ext <;> simp [add_mul, mul_add, smul_add, smul_sub] <;> abel + lie_self a := by + ext <;> simp + leibniz_lie a b c := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [bracket_toSU3Matrix, bracket_toSU2Matrix, bracket_toU1Value, + add_toSU3Matrix, add_toSU2Matrix, add_toU1Value, mul_smul_comm, smul_mul_assoc, + smul_smul, Complex.I_mul_I, smul_sub, mul_sub, sub_mul, mul_assoc, add_zero] <;> + module + +noncomputable instance : LieAlgebra ℝ JetGaugeAlgebra where + lie_smul r a b := by refine ext_of_matrix ?_ ?_ ?_ <;> simp <;> module + +/-! + +## The derivative on the jet gauge algebra + +-/ + +/-- The formal derivative in the direction `μ` on the jet gauge algebra, acting + entrywise on each factor. It preserves hermiticity since `star` commutes with + `pderiv`, and tracelessness since the trace of the entrywise derivative is the + derivative of the trace. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) : JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra where + toFun a := ofMatrixProd + (a.toSU3Matrix.map (pderiv ℂ μ), a.toSU2Matrix.map (pderiv ℂ μ), + pderiv ℂ μ a.toU1Value) + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply, ← JetRing.pderiv_star] using + congrArg (fun M => pderiv ℂ μ (M i j)) + (show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU3Matrix.trace = 0 from a.1.2.2, map_zero]⟩ + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply, ← JetRing.pderiv_star] using + congrArg (fun M => pderiv ℂ μ (M i j)) + (show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU2Matrix.trace = 0 from a.2.1.2.2, map_zero]⟩ + (by rw [← JetRing.pderiv_star, show star a.toU1Value = a.toU1Value from a.2.2.2]) + map_add' a b := by + ext <;> simp [Matrix.map_apply] + map_smul' r a := by + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [ofMatrixProd_toSU3Matrix, ofMatrixProd_toSU2Matrix, ofMatrixProd_toU1Value, + smul_toSU3Matrix, smul_toSU2Matrix, smul_toU1Value, RingHom.id_apply] + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + rw [← algebraMap_smul ℂ r, Derivation.map_smul, algebraMap_smul] + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + rw [← algebraMap_smul ℂ r, Derivation.map_smul, algebraMap_smul] + · rw [← algebraMap_smul ℂ r, Derivation.map_smul, algebraMap_smul] + +@[simp] +lemma deriv_toSU3Matrix (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (deriv μ a).toSU3Matrix = a.toSU3Matrix.map (pderiv ℂ μ) := rfl + +@[simp] +lemma deriv_toSU2Matrix (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (deriv μ a).toSU2Matrix = a.toSU2Matrix.map (pderiv ℂ μ) := rfl + +@[simp] +lemma deriv_toU1Value (μ : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + (deriv μ a).toU1Value = pderiv ℂ μ a.toU1Value := rfl + +/-- Formal derivatives on the jet gauge algebra commute. -/ +lemma deriv_comm (μ ν : Fin 1 ⊕ Fin 3) (a : JetGaugeAlgebra) : + deriv μ (deriv ν a) = deriv ν (deriv μ a) := by + refine ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + simp [Matrix.map_apply, JetRing.pderiv_comm μ ν] + · ext i j : 1 + simp [Matrix.map_apply, JetRing.pderiv_comm μ ν] + · exact JetRing.pderiv_comm μ ν _ + +/-- The derivative is a derivation of the bracket: the Leibniz rule + `deriv μ ⁅x, y⁆ = ⁅deriv μ x, y⁆ + ⁅x, deriv μ y⁆`. -/ +lemma deriv_bracket (μ : Fin 1 ⊕ Fin 3) (x y : JetGaugeAlgebra) : + deriv μ ⁅x, y⁆ = ⁅deriv μ x, y⁆ + ⁅x, deriv μ y⁆ := by + have hleib : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (M N : Matrix κ κ JetRing), + (M * N).map (pderiv ℂ μ) = M.map (pderiv ℂ μ) * N + M * N.map (pderiv ℂ μ) := by + intro κ _ _ M N + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have hsmul : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (c : ℂ) (M : Matrix κ κ JetRing), + (c • M).map (pderiv ℂ μ) = c • M.map (pderiv ℂ μ) := + fun _ _ _ _ _ => Matrix.ext fun _ _ => Derivation.map_smul _ _ _ + have hsub : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (M N : Matrix κ κ JetRing), + (M - N).map (pderiv ℂ μ) = M.map (pderiv ℂ μ) - N.map (pderiv ℂ μ) := by + intro κ _ _ M N + ext i j : 1 + simp only [Matrix.map_apply, Matrix.sub_apply, map_sub] + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [deriv_toSU3Matrix, deriv_toSU2Matrix, deriv_toU1Value, bracket_toSU3Matrix, + bracket_toSU2Matrix, bracket_toU1Value, add_toSU3Matrix, add_toSU2Matrix, + add_toU1Value, hsmul, hsub, hleib, map_zero, add_zero] + · rw [← smul_add] + congr 1 + abel + · rw [← smul_add] + congr 1 + abel + +/-! + +## The iterated derivative + +-/ +/-- Post-composition with `deriv` is right-commutative, since formal derivatives + commute (`deriv_comm`). This is what allows iterated derivatives to be indexed by a + `Multiset` of directions. -/ +instance : RightCommutative + (fun (D : JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra) (μ : Fin 1 ⊕ Fin 3) => D.comp (deriv μ)) where + right_comm D μ ν := by + refine LinearMap.ext fun a => ?_ + exact congrArg D (deriv_comm μ ν a) + +/-- The iterated formal derivative on the jet gauge algebra, in the (unordered, since + derivatives commute) directions given by the multiset `μs`. -/ +noncomputable def iteratedDeriv (μs : Multiset (Fin 1 ⊕ Fin 3)) : + JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra := + μs.foldl (fun D μ => D.comp (deriv μ)) LinearMap.id + +@[simp] +lemma iteratedDeriv_zero : iteratedDeriv 0 = LinearMap.id := by + simp [iteratedDeriv] + +lemma iteratedDeriv_cons (μ : Fin 1 ⊕ Fin 3) (μs : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedDeriv (μ ::ₘ μs) = (deriv μ).comp (iteratedDeriv μs) := by + have h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (D : JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra), + s.foldl (fun D μ => D.comp (deriv μ)) D = D.comp (iteratedDeriv s) := by + intro s + induction s using Multiset.induction_on with + | empty => intro D; simp [iteratedDeriv] + | cons κ t ih => + intro D + rw [iteratedDeriv, Multiset.foldl_cons, Multiset.foldl_cons, ih, ih] + simp [LinearMap.comp_assoc] + rw [iteratedDeriv, Multiset.foldl_cons, h] + simp + +/-- The iterated derivative is additive in the multiset of directions: deriving + along `s + t` is deriving along `t` and then along `s`. -/ +lemma iteratedDeriv_add (s t : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedDeriv (s + t) = (iteratedDeriv s).comp (iteratedDeriv t) := by + induction s using Multiset.induction_on with + | empty => simp [iteratedDeriv_zero] + | cons μ s ih => + rw [Multiset.cons_add, iteratedDeriv_cons, iteratedDeriv_cons, ih, + LinearMap.comp_assoc] + +@[simp] +lemma iteratedDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedDeriv ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = deriv μ := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, iteratedDeriv_cons, + iteratedDeriv_zero, LinearMap.comp_id] + +/-- The iterated Leibniz rule for the bracket: the iterated derivative of a bracket + is the antidiagonal convolution of iterated derivatives of the two arguments. -/ +lemma iteratedDeriv_bracket (s : Multiset (Fin 1 ⊕ Fin 3)) (a b : JetGaugeAlgebra) : + iteratedDeriv s ⁅a, b⁆ = + (s.antidiagonal.map fun p => ⁅iteratedDeriv p.1 a, iteratedDeriv p.2 b⁆).sum := by + induction s using Multiset.induction_on with + | empty => simp [Multiset.antidiagonal_zero] + | cons κ s ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, ih, map_multiset_sum, + Multiset.map_map, + Multiset.map_congr rfl (fun p hp => by + rw [Function.comp_apply, deriv_bracket, + show deriv κ (iteratedDeriv p.1 a) = iteratedDeriv (κ ::ₘ p.1) a from by + rw [iteratedDeriv_cons]; rfl, + show deriv κ (iteratedDeriv p.2 b) = iteratedDeriv (κ ::ₘ p.2) b from by + rw [iteratedDeriv_cons]; rfl]), + Multiset.sum_map_add] + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + abel + + + + +lemma iteratedDeriv_toSU3Matrix (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toSU3Matrix = + a.toSU3Matrix.map fun f => s.foldl (fun f ρ => pderiv ℂ ρ f) f := by + induction s using Multiset.induction_on with + | empty => simp [iteratedDeriv_zero] + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, deriv_toSU3Matrix, ih] + ext i j : 1 + simp only [Matrix.map_apply, Multiset.foldl_cons] + exact (JetRing.foldl_pderiv_pderiv t μ _).symm + +lemma iteratedDeriv_toSU2Matrix (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toSU2Matrix = + a.toSU2Matrix.map fun f => s.foldl (fun f ρ => pderiv ℂ ρ f) f := by + induction s using Multiset.induction_on with + | empty => simp [iteratedDeriv_zero] + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, deriv_toSU2Matrix, ih] + ext i j : 1 + simp only [Matrix.map_apply, Multiset.foldl_cons] + exact (JetRing.foldl_pderiv_pderiv t μ _).symm + +lemma iteratedDeriv_toU1Value (s : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (iteratedDeriv s a).toU1Value = s.foldl (fun f ρ => pderiv ℂ ρ f) a.toU1Value := by + induction s using Multiset.induction_on with + | empty => simp [iteratedDeriv_zero] + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply, deriv_toU1Value, ih, + Multiset.foldl_cons, JetRing.foldl_pderiv_pderiv] + + +/-! + +## Taylor coefficients and evaluation at the base point + +-/ + +/-- The Taylor coefficient of an element of the jet gauge algebra at the monomial + given by the multiset `r` of spacetime directions, taken entrywise, as an + `ℝ`-linear map to the constant gauge algebra `GaugeAlgebra`. + + For `r ≠ 0` this is only linear: the coefficient of a product is a convolution of + coefficients, so it does not respect the bracket. The zeroth coefficient does; see + `eval` for that morphism of Lie algebras. -/ +noncomputable def taylorCoeff (r : Multiset (Fin 1 ⊕ Fin 3)) : + JetGaugeAlgebra →ₗ[ℝ] GaugeAlgebra where + toFun a := GaugeAlgebra.ofMatrixProd + (a.toSU3Matrix.map (coeff r.toFinsupp), a.toSU2Matrix.map (coeff r.toFinsupp), + coeff r.toFinsupp a.toU1Value) + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply] using + congrArg (fun M => coeff r.toFinsupp (M i j)) + (show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU3Matrix.trace = 0 from a.1.2.2, map_zero]⟩ + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply] using + congrArg (fun M => coeff r.toFinsupp (M i j)) + (show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU2Matrix.trace = 0 from a.2.1.2.2, map_zero]⟩ + (by rw [← JetRing.coeff_star, show star a.toU1Value = a.toU1Value from a.2.2.2]) + map_add' a b := by + ext <;> simp [Matrix.map_apply] + map_smul' t a := by + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ <;> + simp only [GaugeAlgebra.ofMatrixProd_toSU3Matrix, GaugeAlgebra.ofMatrixProd_toSU2Matrix, + GaugeAlgebra.ofMatrixProd_toU1Value, smul_toSU3Matrix, smul_toSU2Matrix, smul_toU1Value, + GaugeAlgebra.smul_toSU3Matrix, GaugeAlgebra.smul_toSU2Matrix, GaugeAlgebra.smul_toU1Value, + RingHom.id_apply] + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + rw [← algebraMap_smul ℂ t, map_smul, algebraMap_smul] + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + rw [← algebraMap_smul ℂ t, map_smul, algebraMap_smul] + · rw [← algebraMap_smul ℂ t, map_smul, algebraMap_smul] + +@[simp] +lemma taylorCoeff_toSU3Matrix (r : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (taylorCoeff r a).toSU3Matrix = a.toSU3Matrix.map (coeff r.toFinsupp) := rfl + +@[simp] +lemma taylorCoeff_toSU2Matrix (r : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (taylorCoeff r a).toSU2Matrix = a.toSU2Matrix.map (coeff r.toFinsupp) := rfl + +@[simp] +lemma taylorCoeff_toU1Value (r : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (taylorCoeff r a).toU1Value = coeff r.toFinsupp a.toU1Value := rfl + +/-- The zeroth Taylor coefficient respects the bracket, since the constant coefficient + of a product of jets is the product of the constant coefficients. -/ +lemma taylorCoeff_zero_bracket (a b : JetGaugeAlgebra) : + taylorCoeff 0 ⁅a, b⁆ = ⁅taylorCoeff 0 a, taylorCoeff 0 b⁆ := by + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + simp [Matrix.map_apply, Matrix.mul_apply, smul_eq_mul, + coeff_zero_eq_constantCoeff, map_sum, Finset.mul_sum, mul_sub] + · ext i j : 1 + simp [Matrix.map_apply, Matrix.mul_apply, smul_eq_mul, + coeff_zero_eq_constantCoeff, mul_sub] + · simp + +/-- Evaluation of the jet gauge algebra at the base point: the zeroth Taylor + coefficient, as a morphism of Lie algebras. -/ +noncomputable def eval : JetGaugeAlgebra →ₗ⁅ℝ⁆ GaugeAlgebra := + { taylorCoeff 0 with map_lie' := taylorCoeff_zero_bracket _ _ } + +/-- The inclusion of the constant gauge algebra into the jet gauge algebra: the jets + with no spacetime dependence, given entrywise by the constant power series. This is + a section of `eval`. -/ +noncomputable def ofConstant : GaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra where + toFun a := ofMatrixProd + (a.toSU3Matrix.map (C : ℂ → JetRing), a.toSU2Matrix.map (C : ℂ → JetRing), + C a.toU1Value) + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply] using + congrArg (fun M => (C (M i j) : JetRing)) + (show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU3Matrix.trace = 0 from a.1.2.2, map_zero]⟩ + ⟨by + ext i j : 1 + simpa [Matrix.star_apply, Matrix.map_apply] using + congrArg (fun M => (C (M i j) : JetRing)) + (show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1), + by rw [← AddMonoidHom.map_trace, show a.toSU2Matrix.trace = 0 from a.2.1.2.2, map_zero]⟩ + (by rw [JetRing.star_C, show star a.toU1Value = a.toU1Value from a.2.2.2]) + map_add' a b := by + ext <;> simp [Matrix.map_apply] + map_smul' t a := by + have hC : ∀ x : ℂ, (C (t • x) : JetRing) = t • C x := fun x => by + rw [Algebra.smul_def, Algebra.smul_def, map_mul, MvPowerSeries.algebraMap_apply] + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [ofMatrixProd_toSU3Matrix, ofMatrixProd_toSU2Matrix, ofMatrixProd_toU1Value, + GaugeAlgebra.smul_toSU3Matrix, GaugeAlgebra.smul_toSU2Matrix, + GaugeAlgebra.smul_toU1Value, smul_toSU3Matrix, smul_toSU2Matrix, smul_toU1Value, + RingHom.id_apply] + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + exact hC _ + · ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply] + exact hC _ + · exact hC _ + +@[simp] +lemma ofConstant_toSU3Matrix (a : GaugeAlgebra) : + (ofConstant a).toSU3Matrix = a.toSU3Matrix.map (C : ℂ → JetRing) := rfl + +@[simp] +lemma ofConstant_toSU2Matrix (a : GaugeAlgebra) : + (ofConstant a).toSU2Matrix = a.toSU2Matrix.map (C : ℂ → JetRing) := rfl + +@[simp] +lemma ofConstant_toU1Value (a : GaugeAlgebra) : + (ofConstant a).toU1Value = C a.toU1Value := rfl + +lemma eval_apply (a : JetGaugeAlgebra) : eval a = taylorCoeff 0 a := rfl + +@[simp] +lemma eval_ofConstant (a : GaugeAlgebra) : eval (ofConstant a) = a := by + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + simp [Matrix.map_apply, eval_apply, coeff_zero_eq_constantCoeff, constantCoeff_C] + · ext i j : 1 + simp [Matrix.map_apply, eval_apply, coeff_zero_eq_constantCoeff, constantCoeff_C] + · simp [coeff_zero_eq_constantCoeff, eval_apply, constantCoeff_C] + + +lemma eval_toSU3Matrix_apply (a : JetGaugeAlgebra) (i j : Fin 3) : + (eval a).toSU3Matrix i j = constantCoeff (a.toSU3Matrix i j) := by + rw [show eval a = taylorCoeff 0 a from rfl, taylorCoeff_toSU3Matrix, Matrix.map_apply, + show Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)) = 0 from map_zero _, + coeff_zero_eq_constantCoeff] + +lemma eval_toSU2Matrix_apply (a : JetGaugeAlgebra) (i j : Fin 2) : + (eval a).toSU2Matrix i j = constantCoeff (a.toSU2Matrix i j) := by + rw [show eval a = taylorCoeff 0 a from rfl, taylorCoeff_toSU2Matrix, Matrix.map_apply, + show Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)) = 0 from map_zero _, + coeff_zero_eq_constantCoeff] + +lemma eval_toU1Value_eq (a : JetGaugeAlgebra) : + (eval a).toU1Value = constantCoeff a.toU1Value := by + rw [show eval a = taylorCoeff 0 a from rfl, taylorCoeff_toU1Value, + show Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)) = 0 from map_zero _, + coeff_zero_eq_constantCoeff] + + +/-- Taylor determinacy: a jet gauge algebra element is determined by the base-point + values of its iterated derivatives. -/ +theorem ext_of_eval_iteratedDeriv {x y : JetGaugeAlgebra} + (h : ∀ s, eval (iteratedDeriv s x) = eval (iteratedDeriv s y)) : x = y := by + have key : ∀ (n : ℕ) (x y : JetGaugeAlgebra), + (∀ s, eval (iteratedDeriv s x) = eval (iteratedDeriv s y)) → + ∀ m : (Fin 1 ⊕ Fin 3) →₀ ℕ, Finsupp.degree m = n → + (∀ i j, coeff m (x.toSU3Matrix i j) = coeff m (y.toSU3Matrix i j)) ∧ + (∀ i j, coeff m (x.toSU2Matrix i j) = coeff m (y.toSU2Matrix i j)) ∧ + coeff m x.toU1Value = coeff m y.toU1Value := by + intro n + induction n with + | zero => + intro x y hxy m hm + have hm0 : m = 0 := (Finsupp.degree_eq_zero_iff m).mp hm + subst hm0 + have h0 := hxy 0 + rw [iteratedDeriv_zero] at h0 + simp only [LinearMap.id_coe, id_eq] at h0 + have h0' : taylorCoeff 0 x = taylorCoeff 0 y := h0 + refine ⟨fun i j => ?_, fun i j => ?_, ?_⟩ + · simpa [Matrix.map_apply] using + congrArg (fun g => GaugeAlgebra.toSU3Matrix g i j) h0' + · simpa [Matrix.map_apply] using + congrArg (fun g => GaugeAlgebra.toSU2Matrix g i j) h0' + · simpa using congrArg GaugeAlgebra.toU1Value h0' + | succ n ih => + intro x y hxy m hm + -- pick a direction occurring in `m` and peel one derivative off + have hm0 : m ≠ 0 := fun h0 => by simp [h0] at hm + obtain ⟨μ, hμ⟩ := Finsupp.ne_iff.mp hm0 + simp only [Finsupp.coe_zero, Pi.zero_apply] at hμ + have hle : Finsupp.single μ 1 ≤ m := by + rw [Finsupp.single_le_iff] + omega + have hm'' : m - Finsupp.single μ 1 + Finsupp.single μ 1 = m := + tsub_add_cancel_of_le hle + have hdeg' : Finsupp.degree (m - Finsupp.single μ 1) = n := by + have h1 := congrArg Finsupp.degree hm'' + rw [map_add, Finsupp.degree_single, hm] at h1 + omega + -- the derivative pair inherits the hypothesis, by additivity of `iteratedDeriv` + have hd : ∀ s, eval (iteratedDeriv s (deriv μ x)) = + eval (iteratedDeriv s (deriv μ y)) := by + intro s + have h1 := hxy (s + {μ}) + rwa [iteratedDeriv_add, LinearMap.comp_apply, iteratedDeriv_singleton] at h1 + obtain ⟨k3, k2, k1⟩ := ih (deriv μ x) (deriv μ y) hd (m - Finsupp.single μ 1) hdeg' + refine ⟨fun i j => ?_, fun i j => ?_, ?_⟩ + · have hk := k3 i j + simp only [deriv_toSU3Matrix, Matrix.map_apply] at hk + rw [coeff_pderiv, coeff_pderiv, hm''] at hk + exact mul_right_cancel₀ (Nat.cast_add_one_ne_zero _) hk + · have hk := k2 i j + simp only [deriv_toSU2Matrix, Matrix.map_apply] at hk + rw [coeff_pderiv, coeff_pderiv, hm''] at hk + exact mul_right_cancel₀ (Nat.cast_add_one_ne_zero _) hk + · have hk := k1 + simp only [deriv_toU1Value] at hk + rw [coeff_pderiv, coeff_pderiv, hm''] at hk + exact mul_right_cancel₀ (Nat.cast_add_one_ne_zero _) hk + refine ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + ext m + exact (key (Finsupp.degree m) x y h m rfl).1 i j + · ext i j : 1 + ext m + exact (key (Finsupp.degree m) x y h m rfl).2.1 i j + · ext m + exact (key (Finsupp.degree m) x y h m rfl).2.2 + +/-- Bracket congruence: the base-point Taylor data of an iterated derivative of a + bracket depends only on the corresponding Taylor data of the two arguments. -/ +lemma eval_iteratedDeriv_bracket_congr (w : Multiset (Fin 1 ⊕ Fin 3)) + (a b a' b' : JetGaugeAlgebra) + (ha : ∀ p ≤ w, eval (iteratedDeriv p a) = eval (iteratedDeriv p a')) + (hb : ∀ p ≤ w, eval (iteratedDeriv p b) = eval (iteratedDeriv p b')) : + eval (iteratedDeriv w ⁅a, b⁆) = eval (iteratedDeriv w ⁅a', b'⁆) := by + induction w using Multiset.induction_on generalizing a b a' b' with + | empty => + have ha0 := ha 0 le_rfl + have hb0 := hb 0 le_rfl + rw [iteratedDeriv_zero] at ha0 hb0 ⊢ + simp only [LinearMap.id_coe, id_eq] at ha0 hb0 ⊢ + rw [LieHom.map_lie, LieHom.map_lie, ha0, hb0] + | cons ρ w ihw => + have hcons : ∀ c : JetGaugeAlgebra, + iteratedDeriv (ρ ::ₘ w) c = iteratedDeriv w (deriv ρ c) := by + intro c + rw [show (ρ ::ₘ w : Multiset (Fin 1 ⊕ Fin 3)) = w + {ρ} from by + rw [add_comm, Multiset.singleton_add], + iteratedDeriv_add, LinearMap.comp_apply, iteratedDeriv_singleton] + have htrans : ∀ (c c' : JetGaugeAlgebra), + (∀ p ≤ ρ ::ₘ w, eval (iteratedDeriv p c) = eval (iteratedDeriv p c')) → + ∀ p ≤ w, eval (iteratedDeriv p (deriv ρ c)) = eval (iteratedDeriv p (deriv ρ c')) := by + intro c c' hc p hp + have h1 := hc (p + {ρ}) (by + rw [show (ρ ::ₘ w : Multiset (Fin 1 ⊕ Fin 3)) = w + {ρ} from by + rw [add_comm, Multiset.singleton_add]] + exact add_le_add hp le_rfl) + rwa [iteratedDeriv_add, LinearMap.comp_apply, iteratedDeriv_singleton] at h1 + have hrest : ∀ (c c' : JetGaugeAlgebra), + (∀ p ≤ ρ ::ₘ w, eval (iteratedDeriv p c) = eval (iteratedDeriv p c')) → + ∀ p ≤ w, eval (iteratedDeriv p c) = eval (iteratedDeriv p c') := + fun c c' hc p hp => hc p (hp.trans (Multiset.le_cons_self w ρ)) + rw [hcons, hcons, deriv_bracket, deriv_bracket, map_add, map_add, map_add, map_add] + rw [ihw _ _ _ _ (htrans a a' ha) (hrest b b' hb), + ihw _ _ _ _ (hrest a a' ha) (htrans b b' hb)] + +/-! + +## The basis + +-/ + +TODO "Define the basis of the jet gauge algebra." + + +/-! + +## The adjoint representation of Jet Gauge group + +-/ + +/-- The adjoint action of an element `U` of the jet gauge group on the jet gauge algebra, + acting on the `su(3)` and `su(2)` factors by `a ↦ U a U⁻¹`, with `U⁻¹ = star U` by + unitarity, and trivially on the `u(1)` factor since `JetRing` is commutative. + Hermiticity is preserved since `star (U a (star U)) = U (star a) (star U)`, and + tracelessness since the trace is invariant under conjugation. -/ +noncomputable def adjointMap (U : JetGaugeGroupI) : JetGaugeAlgebra →ₗ[ℝ] JetGaugeAlgebra where + toFun a := ofMatrixProd + (U.1.1 * a.toSU3Matrix * star U.1.1, + U.2.1.1 * a.toSU2Matrix * star U.2.1.1, + a.toU1Value) + ⟨by + rw [star_mul, star_mul, star_star, + show star a.toSU3Matrix = a.toSU3Matrix from a.1.2.1, mul_assoc], + by + rw [Matrix.trace_mul_comm, ← mul_assoc, + show star U.1.1 * U.1.1 = 1 from mem_unitaryGroup_iff'.mp + (mem_specialUnitaryGroup_iff.mp U.1.2).1, + one_mul, show a.toSU3Matrix.trace = 0 from a.1.2.2]⟩ + ⟨by + rw [star_mul, star_mul, star_star, + show star a.toSU2Matrix = a.toSU2Matrix from a.2.1.2.1] + exact (mul_assoc _ _ _).symm, + by + rw [Matrix.trace_mul_comm, ← mul_assoc, + show star U.2.1.1 * U.2.1.1 = 1 from mem_unitaryGroup_iff'.mp + (mem_specialUnitaryGroup_iff.mp U.2.1.2).1, + one_mul, show a.toSU2Matrix.trace = 0 from a.2.1.2.2]⟩ + (show star a.toU1Value = a.toU1Value from a.2.2.2) + map_add' a b := by + ext <;> simp [mul_add, add_mul] + map_smul' r a := by + ext <;> simp + +@[simp] +lemma adjointMap_toSU3Matrix (U : JetGaugeGroupI) (a : JetGaugeAlgebra) : + (adjointMap U a).toSU3Matrix = U.1.1 * a.toSU3Matrix * star U.1.1 := rfl + +@[simp] +lemma adjointMap_toSU2Matrix (U : JetGaugeGroupI) (a : JetGaugeAlgebra) : + (adjointMap U a).toSU2Matrix = U.2.1.1 * a.toSU2Matrix * star U.2.1.1 := rfl + +@[simp] +lemma adjointMap_toU1Value (U : JetGaugeGroupI) (a : JetGaugeAlgebra) : + (adjointMap U a).toU1Value = a.toU1Value := rfl + +/-- The adjoint representation of the jet gauge group on the jet gauge algebra, + `U ↦ (a ↦ U a U⁻¹)` factorwise. -/ +noncomputable def adjoint : Representation ℝ JetGaugeGroupI JetGaugeAlgebra where + toFun := adjointMap + map_one' := by + refine LinearMap.ext fun a => ?_ + ext <;> simp + map_mul' U V := by + refine LinearMap.ext fun a => ?_ + ext <;> simp [star_mul, mul_assoc] + +/-- Evaluating the adjoint action of a gauge jet on a constant at the base point is + the adjoint action of the base-point value of the jet. -/ +lemma eval_adjointMap_ofConstant (U : JetGaugeGroupI) (a : GaugeAlgebra) : + eval (adjointMap U (ofConstant a)) = GaugeAlgebra.adjoint U.eval a := by + have hmap : ∀ {n : Type} [Fintype n] [DecidableEq n] (M : Matrix n n JetRing), + M.map (coeff (Multiset.toFinsupp (0 : Multiset (Fin 1 ⊕ Fin 3)))) = + (constantCoeff : JetRing →+* ℂ).mapMatrix M := by + intro n _ _ M + ext i j + simp [Matrix.map_apply, RingHom.mapMatrix_apply, coeff_zero_eq_constantCoeff] + have hC3 : (constantCoeff : JetRing →+* ℂ).mapMatrix (a.toSU3Matrix.map C) + = a.toSU3Matrix := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, constantCoeff_C] + have hC2 : (constantCoeff : JetRing →+* ℂ).mapMatrix (a.toSU2Matrix.map C) + = a.toSU2Matrix := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, constantCoeff_C] + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · simp only [eval_apply, taylorCoeff_toSU3Matrix, adjointMap_toSU3Matrix, + ofConstant_toSU3Matrix, GaugeAlgebra.adjoint_toSU3Matrix] + rw [hmap, map_mul, map_mul, JetRing.mapMatrix_constantCoeff_star, hC3] + rfl + · simp only [eval_apply, taylorCoeff_toSU2Matrix, adjointMap_toSU2Matrix, + ofConstant_toSU2Matrix, GaugeAlgebra.adjoint_toSU2Matrix] + rw [hmap, map_mul, map_mul, JetRing.mapMatrix_constantCoeff_star, hC2] + rfl + · simp [eval_apply, taylorCoeff_toU1Value, adjointMap_toU1Value, ofConstant_toU1Value, + coeff_zero_eq_constantCoeff, constantCoeff_C, GaugeAlgebra.adjoint_toU1Value] + +/-- The constant inclusion is a morphism of Lie algebras: constants bracket to + constants. -/ +lemma ofConstant_lie (a b : GaugeAlgebra) : + ofConstant ⁅a, b⁆ = ⁅ofConstant a, ofConstant b⁆ := by + refine ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + simp [Matrix.map_apply, Matrix.mul_apply, Matrix.smul_apply, smul_eq_mul, + MvPowerSeries.smul_eq_C_mul, map_sum, Finset.mul_sum, mul_sub] + · ext i j : 1 + simp [Matrix.map_apply, Matrix.mul_apply, Matrix.smul_apply, smul_eq_mul, + MvPowerSeries.smul_eq_C_mul, mul_sub] + · simp + +/-- The adjoint action preserves the bracket: conjugation is an automorphism of the + Lie algebra, using unitarity to cancel the inner `U† U` factors. -/ +lemma adjointMap_lie (U : JetGaugeGroupI) (x y : JetGaugeAlgebra) : + adjointMap U ⁅x, y⁆ = ⁅adjointMap U x, adjointMap U y⁆ := by + refine ext_of_matrix ?_ ?_ ?_ + · have hU : star U.1.1 * U.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h + have key : ∀ X Y : Matrix (Fin 3) (Fin 3) JetRing, + (U.1.1 * X * star U.1.1) * (U.1.1 * Y * star U.1.1) = + U.1.1 * (X * Y) * star U.1.1 := by + intro X Y + simp only [mul_assoc] + rw [show star U.1.1 * (U.1.1 * (Y * star U.1.1)) = Y * star U.1.1 from by + rw [← mul_assoc, hU, one_mul]] + simp only [adjointMap_toSU3Matrix, bracket_toSU3Matrix, mul_smul_comm, smul_mul_assoc] + rw [key, key, mul_sub, sub_mul] + · have hU : star U.2.1.1 * U.2.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h + have key : ∀ X Y : Matrix (Fin 2) (Fin 2) JetRing, + (U.2.1.1 * X * star U.2.1.1) * (U.2.1.1 * Y * star U.2.1.1) = + U.2.1.1 * (X * Y) * star U.2.1.1 := by + intro X Y + simp only [mul_assoc] + rw [show star U.2.1.1 * (U.2.1.1 * (Y * star U.2.1.1)) = Y * star U.2.1.1 from by + rw [← mul_assoc, hU, one_mul]] + simp only [adjointMap_toSU2Matrix, bracket_toSU2Matrix, mul_smul_comm, smul_mul_assoc] + rw [key, key, mul_sub, sub_mul] + · simp + +end JetGaugeAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Basic.lean b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Basic.lean new file mode 100644 index 000000000..b3d0295d1 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Basic.lean @@ -0,0 +1,1251 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Truncation +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Basic +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +/-! +# Algebra valued gauge bosons + +An algebra `B` (for instance a jet algebra of Lagrangian terms) may contain a family of +elements playing the role of the gauge-field symbols `[∂_s A_μ^a]`. This file defines +what it means for such a family to *be* a set of gauge bosons: the structure +`IsGaugeField` records the transformation laws that the physicists' gauge field +satisfies, with nothing postulated beyond them. + +## The physics + +Let `A_μ^a` be a gauge field for the gauge group `G`, with `μ` a spacetime (covector) +index and `a` an adjoint index. Under a gauge transformation `g` the field transforms as + + `A_μ ↦ Ad_g A_μ + mc(g)_μ`, + +where `mc(g)_μ = i (∂_μ g) g⁻¹` is the Maurer–Cartan form. The symbols `[∂_s A_μ^a]` +are coordinate functions on the space of field configurations, so the induced (left) +action is the pullback along `g⁻¹`: one substitutes `g⁻¹` into the field law and +differentiates `s` times with the Leibniz rule: + + `g • [∂_s A_μ^a] = ∑_{x+y=s} C(x,y) (∂_x (Ad_{g⁻¹})^a_b)| [∂_y A_μ^b]` + ` + (∂_s mc(g⁻¹)_μ^a)|`, + +where `C(x,y)` is the multinomial coefficient of the splitting and `|` denotes +evaluation at the base point. All the data on the right is carried by the *jet* of the +gauge transformation, which is why the gauge representation below is a representation +of `JetGaugeGroupI` and not merely of `GaugeGroupI`. + +## The formalization dictionary + +* `A μ φ` is the symbol `A_μ^a` contracted with a dual adjoint vector `φ`; the + derivative symbols `[∂_s A_μ^a]` are its images `iteratedD D deriv_comm s (A μ φ)` under the + total derivative `D`. +* `∂_x (Ad_{g⁻¹})^a_b|` acting on the dual index is `adjointDualCoeff g⁻¹ x φ`: + include the constant algebra element into jets, act by the adjoint of `g⁻¹`, + differentiate `x` times, evaluate at the base point, and pair with `φ`. +* The sum `∑_{x+y=s} C(x,y)` is the sum over `s.antidiagonal`: a splitting `(x, y)` + occurs in the antidiagonal of the multiset `s` with multiplicity exactly `C(x,y)`. +* `(∂_s mc(g⁻¹)_μ)|` is `JetGaugeAlgebra.eval (iteratedDeriv s (maurerCartanForm g⁻¹ μ))`, + a constant algebra element, paired with `φ` and embedded in `B` as a scalar. + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] [Algebra ℂ B] + + +/-- The physicists' `∂_x (Ad_{U})^a_b|` acting on the dual adjoint index of a + gauge-field symbol: precomposition of `φ` with the constant inclusion into jets, + followed by the adjoint action of `U`, `x` formal derivatives, and evaluation at + the base point. For `x = 0` this is the dual (contragredient) adjoint action of + the value `U₀`; for `x ≠ 0` it sees the derivatives of the gauge transformation. -/ +noncomputable def adjointDualCoeff (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] Module.Dual ℝ GaugeAlgebra := + (JetGaugeAlgebra.eval.toLinearMap ∘ₗ JetGaugeAlgebra.iteratedDeriv x ∘ₗ + JetGaugeAlgebra.adjointMap U ∘ₗ JetGaugeAlgebra.ofConstant).dualMap + +/-- The zeroth dual adjoint coefficient is the dual of the adjoint action of the + base-point value of the gauge jet. -/ +lemma adjointDualCoeff_zero (U : JetGaugeGroupI) : + adjointDualCoeff U 0 = (GaugeAlgebra.adjoint U.eval).dualMap := by + rw [adjointDualCoeff] + refine congrArg LinearMap.dualMap (LinearMap.ext fun a => ?_) + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap, + JetGaugeAlgebra.iteratedDeriv_zero, LinearMap.id_coe, id_eq] + exact JetGaugeAlgebra.eval_adjointMap_ofConstant U a + +/-- For a gauge jet whose value at the base point is the identity, the zeroth dual + adjoint coefficient is trivial: the base-point adjoint action `Ad_{U₀}` is the + identity. -/ +lemma adjointDualCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + adjointDualCoeff U 0 = LinearMap.id := by + rw [adjointDualCoeff_zero, hU, map_one, Module.End.one_eq_id, LinearMap.dualMap_id] + +/-- The dual adjoint coefficient at a single derivative: since + `∂_μ (Ad_U x) = Ad_U (∂_μ x) − ⁅ω_μ(U), Ad_U x⁆` (`deriv_adjointMap`) and constants + have vanishing derivative, the once-derived coefficient is minus the underived + coefficient precomposed (on the dual index) with `ad` of the base-point + Maurer–Cartan form. This is what cancels the Leibniz cross terms of + `gauge_apply_deriv` against the commutator cross terms in the field strength. -/ +lemma adjointDualCoeff_singleton (U : JetGaugeGroupI) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + adjointDualCoeff U {μ} φ = + -adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (maurerCartanForm U μ))) := by + refine LinearMap.ext fun a => ?_ + simp only [adjointDualCoeff, LinearMap.dualMap_apply, LinearMap.neg_apply, + LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap, + JetGaugeAlgebra.iteratedDeriv_singleton, JetGaugeAlgebra.iteratedDeriv_zero, + LinearMap.id_coe, id_eq] + rw [deriv_adjointMap, JetGaugeAlgebra.deriv_ofConstant, map_zero, zero_sub, map_neg, + map_neg, LieHom.map_lie] + simp + +/-- **Deep kernels kill the positive dual adjoint coefficients**: for a jet trivial to order `n`, all derivatives of the + adjoint action up to order `n` vanish. -/ +lemma adjointDualCoeff_eq_zero_of_mem_truncationKer {U : JetGaugeGroupI} {n : ℕ} + (hU : U ∈ JetGaugeGroupI.truncationKer n) {x : Multiset (Fin 1 ⊕ Fin 3)} + (hx : x ≠ 0) (hxn : x.card ≤ n) : adjointDualCoeff U x = 0 := by + have hprod := JetGaugeGroupI.mem_truncationKer_iff.mp hU + -- the truncations of the matrix factors of `U` agree with `1` + have h3 : U.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.1) hprod + have h2 : U.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.2.1) hprod + have hs3 : (star U.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := by + rw [JetRing.matrix_truncation_star, h3, ← JetRing.matrix_truncation_star, star_one] + have hs2 : (star U.2.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := by + rw [JetRing.matrix_truncation_star, h2, ← JetRing.matrix_truncation_star, star_one] + -- conjugation by `U` is invisible to the `n`-th truncation + have hconj3 : ∀ M : Matrix (Fin 3) (Fin 3) JetRing, + ((U.1.1 * M) * star U.1.1).map (JetRing.truncation n) = + M.map (JetRing.truncation n) := by + intro M + rw [JetRing.matrix_truncation_mul_congr + (JetRing.matrix_truncation_mul_congr h3 rfl) hs3, one_mul, mul_one] + have hconj2 : ∀ M : Matrix (Fin 2) (Fin 2) JetRing, + ((U.2.1.1 * M) * star U.2.1.1).map (JetRing.truncation n) = + M.map (JetRing.truncation n) := by + intro M + rw [JetRing.matrix_truncation_mul_congr + (JetRing.matrix_truncation_mul_congr h2 rfl) hs2, one_mul, mul_one] + -- the multiset `x` sits in the truncation window, in nonzero degree + have hdeg : Finsupp.degree (Multiset.toFinsupp x) ≤ n := by + rw [JetRing.degree_toFinsupp_eq_card]; exact hxn + have hne : Multiset.toFinsupp x ≠ 0 := fun hc => + hx (by simpa using congrArg Finsupp.toMultiset hc) + -- the underlying derivative of the adjoint transport vanishes at the base point + have key : ∀ b : GaugeAlgebra, + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv x + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant b))) = 0 := by + intro b + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + rw [JetGaugeAlgebra.eval_toSU3Matrix_apply, JetGaugeAlgebra.iteratedDeriv_toSU3Matrix, + Matrix.map_apply, JetRing.constantCoeff_foldl_pderiv, + JetGaugeAlgebra.adjointMap_toSU3Matrix, JetGaugeAlgebra.ofConstant_toSU3Matrix] + have h1 := congrArg (fun M : Matrix (Fin 3) (Fin 3) JetRing => M i j) + (hconj3 (b.toSU3Matrix.map (C : ℂ → JetRing))) + simp only [Matrix.map_apply] at h1 + have hcoeff := congrArg (fun f => coeff (Multiset.toFinsupp x) f) h1 + simp only [JetRing.coeff_truncation_of_le hdeg] at hcoeff + rw [hcoeff, coeff_C, if_neg hne, mul_zero, + GaugeAlgebra.zero_toSU3Matrix, Matrix.zero_apply] + · ext i j : 1 + rw [JetGaugeAlgebra.eval_toSU2Matrix_apply, JetGaugeAlgebra.iteratedDeriv_toSU2Matrix, + Matrix.map_apply, JetRing.constantCoeff_foldl_pderiv, + JetGaugeAlgebra.adjointMap_toSU2Matrix, JetGaugeAlgebra.ofConstant_toSU2Matrix] + have h1 := congrArg (fun M : Matrix (Fin 2) (Fin 2) JetRing => M i j) + (hconj2 (b.toSU2Matrix.map (C : ℂ → JetRing))) + simp only [Matrix.map_apply] at h1 + have hcoeff := congrArg (fun f => coeff (Multiset.toFinsupp x) f) h1 + simp only [JetRing.coeff_truncation_of_le hdeg] at hcoeff + rw [hcoeff, coeff_C, if_neg hne, mul_zero, + GaugeAlgebra.zero_toSU2Matrix, Matrix.zero_apply] + · rw [JetGaugeAlgebra.eval_toU1Value_eq, JetGaugeAlgebra.iteratedDeriv_toU1Value, + JetGaugeAlgebra.adjointMap_toU1Value, JetGaugeAlgebra.ofConstant_toU1Value, + JetRing.constantCoeff_foldl_pderiv, coeff_C, if_neg hne, mul_zero, + GaugeAlgebra.zero_toU1Value] + refine LinearMap.ext fun φ => LinearMap.ext fun b => ?_ + simp only [LinearMap.zero_apply] + show φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv x + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant b)))) = 0 + rw [key b, map_zero] + +open Lorentz +/-- The family `A` of symbols in the algebra `B` is a gauge field for the total + derivative `D`, the Lorentz representation `repLorentz` and the gauge representation + `repGauge`, when it satisfies the transformation laws of the physicists' gauge field: + + * it presupposes (as arguments, not fields) that `D` is a Lorentz derivative — the + instance `Lorentz.IsLorentzDeriv repLorentz D` — and that its components commute + (`deriv_comm`), as total derivatives do; + * the symbol `A_μ^a` carries one covector index, transforming through the columns of + the Lorentz matrix (`lorentz_A`); + * under a gauge jet `U` the derivative symbols `[∂_s A_μ^a]` transform by the + Leibniz expansion of `A_μ ↦ Ad_{U⁻¹} A_μ + mc(U⁻¹)_μ` (`gauge_A`) — the adjoint + convolution plus the inhomogeneous Maurer–Cartan shift. The inverse makes the + action a left action, exactly as in `φ'(x) = φ(Λ⁻¹ x)`. -/ +structure IsGaugeField (repLorentz : Representation ℂ SL(2,ℂ) B) + (repGauge : Representation ℂ JetGaugeGroupI B) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : Prop where + /-- The gauge-field symbol carries one covector Lorentz index. -/ + lorentz_apply : ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + repLorentz Λ (A (List.ofFn l) μ φ) = + ∑ (p : Fin n → (Fin 1 ⊕ Fin 3)), + (∏ (i : Fin n), (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • A (List.ofFn p) a φ + /-- The gauge transformation of the derivative symbols `[∂_s A_μ^a]`: the Leibniz + convolution of the dual adjoint action of `U⁻¹` against lower derivative symbols + (the multiset antidiagonal carries the multinomial coefficients), plus the + base-point value of the `s`-th derivative of the Maurer–Cartan form of `U⁻¹`. -/ + gauge_apply_deriv : ∀ (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + repGauge U (A s μ φ) = + (s.antidiagonal.map fun p => (A p.2 μ (adjointDualCoeff U⁻¹ p.1 φ))).sum + + algebraMap ℂ B + (φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s (maurerCartanForm U⁻¹ μ)))) + /-- The gauge action preserves products: gauge transformations act on the algebra of + local expressions as algebra homomorphisms. -/ + gauge_mul : ∀ (U : JetGaugeGroupI) (b₁ b₂ : B), + repGauge U (b₁ * b₂) = repGauge U b₁ * repGauge U b₂ + +namespace IsGaugeField + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-- The canonical equivalence, through finite-dimensional duality, between + algebra-valued fields `B ⊗ 𝔤` and their component families `φ ↦ A^φ`: the element + `b ⊗ a` corresponds to the family `φ ↦ φ(a) b`. -/ +noncomputable def dualPairEquiv : + (B ⊗[ℝ] GaugeAlgebra) ≃ₗ[ℝ] (Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) := + TensorProduct.comm ℝ B GaugeAlgebra ≪≫ₗ + TensorProduct.congr (Module.evalEquiv ℝ GaugeAlgebra) (LinearEquiv.refl ℝ B) ≪≫ₗ + dualTensorHomEquiv ℝ (Module.Dual ℝ GaugeAlgebra) B + +/-- The bracket of two algebra-valued fields: multiplication in `B` on the first + factors, the Lie bracket of the gauge algebra on the second, so that on pure + tensors `⁅b₁ ⊗ a₁, b₂ ⊗ a₂⁆ = (b₁ b₂) ⊗ ⁅a₁, a₂⁆`. -/ +noncomputable def tensorBracket : + (B ⊗[ℝ] GaugeAlgebra) →ₗ[ℝ] (B ⊗[ℝ] GaugeAlgebra) →ₗ[ℝ] B ⊗[ℝ] GaugeAlgebra := + TensorProduct.curry + ((TensorProduct.map (TensorProduct.lift (LinearMap.mul ℝ B)) + (TensorProduct.lift (LinearMap.mk₂ ℝ (fun a b => ⁅a, b⁆) + (fun a a' b => add_lie a a' b) (fun t a b => smul_lie t a b) + (fun a b b' => lie_add a b b') (fun t a b => lie_smul t a b)))) ∘ₗ + (TensorProduct.tensorTensorTensorComm ℝ B GaugeAlgebra B GaugeAlgebra).toLinearMap) + +/-- The commutator term `⁅A_μ, A_ν⁆` of the field strength, as a component family: + the physicists' `f^a_{bc} A_μ^b A_ν^c` contracted with a dual adjoint vector, but + basis-free — the two fields are assembled into `B ⊗ 𝔤` by `dualPairEquiv.symm`, + bracketed there by `tensorBracket`, and read back out as components. -/ +noncomputable def commutator + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + dualPairEquiv (tensorBracket (dualPairEquiv.symm (A 0 μ)) (dualPairEquiv.symm (A 0 ν))) + +/-- The gauge transformation of the underived symbol `A_μ^φ`: the special case `s = 0` + of `gauge_apply_deriv`, with no Leibniz convolution left over — the dual adjoint + action of the value of `U⁻¹` plus the Maurer–Cartan shift. -/ +lemma repGauge_apply (hA : IsGaugeField repLorentz repGauge A) (U : JetGaugeGroupI) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (A 0 μ φ) = A 0 μ (adjointDualCoeff U⁻¹ ∅ φ) + + algebraMap ℂ B (φ (JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ μ))) := by + simpa [show (∅ : Multiset (Fin 1 ⊕ Fin 3)) = 0 from rfl] using + hA.gauge_apply_deriv U 0 μ φ + + +/-- The gauge transformation of the once-derived symbol `∂_ρ A_σ`: the case `s = {ρ}` + of `gauge_apply_deriv` — the two Leibniz splittings of one derivative, plus the + base-point value of the derived Maurer–Cartan form. -/ +lemma repGauge_deriv_apply (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (ρ σ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (A {ρ} σ φ) = + A {ρ} σ (adjointDualCoeff U⁻¹ 0 φ) + A 0 σ (adjointDualCoeff U⁻¹ {ρ} φ) + + algebraMap ℂ B (φ (JetGaugeAlgebra.eval + (JetGaugeAlgebra.deriv ρ (maurerCartanForm U⁻¹ σ)))) := by + have hanti : ({ρ} : Multiset (Fin 1 ⊕ Fin 3)).antidiagonal = + {((0 : Multiset (Fin 1 ⊕ Fin 3)), ({ρ} : Multiset (Fin 1 ⊕ Fin 3))), + (({ρ} : Multiset (Fin 1 ⊕ Fin 3)), (0 : Multiset (Fin 1 ⊕ Fin 3)))} := by + rw [show ({ρ} : Multiset (Fin 1 ⊕ Fin 3)) = ρ ::ₘ 0 from rfl, + Multiset.antidiagonal_cons, Multiset.antidiagonal_zero] + simp + have h := hA.gauge_apply_deriv U {ρ} σ φ + rw [hanti] at h + simp only [Multiset.insert_eq_cons, Multiset.map_cons, Multiset.map_singleton, + Multiset.sum_cons, Multiset.sum_singleton, + JetGaugeAlgebra.iteratedDeriv_singleton] at h + refine h.trans ?_ + abel + +/-! + +## Pure-tensor computations for `dualPairEquiv` and `tensorBracket` + +-/ + +@[simp] +lemma dualPairEquiv_tmul (b : B) (a : GaugeAlgebra) (φ : Module.Dual ℝ GaugeAlgebra) : + dualPairEquiv (b ⊗ₜ[ℝ] a) φ = φ a • b := by + simp [dualPairEquiv, dualTensorHomEquiv, Module.evalEquiv_apply] + +@[simp] +lemma tensorBracket_tmul (b₁ b₂ : B) (a₁ a₂ : GaugeAlgebra) : + tensorBracket (b₁ ⊗ₜ[ℝ] a₁) (b₂ ⊗ₜ[ℝ] a₂) = (b₁ * b₂) ⊗ₜ[ℝ] ⁅a₁, a₂⁆ := by + simp [tensorBracket, TensorProduct.tensorTensorTensorComm_tmul] + +lemma dualPairEquiv_map_left (Φ : B →ₗ[ℝ] B) (t : B ⊗[ℝ] GaugeAlgebra) + (φ : Module.Dual ℝ GaugeAlgebra) : + dualPairEquiv ((TensorProduct.map Φ LinearMap.id) t) φ = Φ (dualPairEquiv t φ) := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b a => simp + | add x y hx hy => simp [hx, hy] + +lemma dualPairEquiv_map_right (T : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (t : B ⊗[ℝ] GaugeAlgebra) (φ : Module.Dual ℝ GaugeAlgebra) : + dualPairEquiv ((TensorProduct.map LinearMap.id T) t) φ = + dualPairEquiv t (T.dualMap φ) := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b a => simp + | add x y hx hy => simp [hx, hy] + +lemma dualPairEquiv_one_tmul (c : GaugeAlgebra) (φ : Module.Dual ℝ GaugeAlgebra) : + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] c) φ = algebraMap ℂ B (φ c) := by + rw [dualPairEquiv_tmul, Algebra.algebraMap_eq_smul_one, + show ((φ c : ℝ) : ℂ) = algebraMap ℝ ℂ (φ c) from rfl, algebraMap_smul] + +lemma symm_comp_left (Φ : B →ₗ[ℝ] B) (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + dualPairEquiv.symm (Φ ∘ₗ f) = + (TensorProduct.map Φ LinearMap.id) (dualPairEquiv.symm f) := by + apply dualPairEquiv.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + rw [dualPairEquiv_map_left, LinearEquiv.apply_symm_apply] + rfl + +lemma symm_comp_right (T : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + dualPairEquiv.symm (f ∘ₗ T.dualMap) = + (TensorProduct.map LinearMap.id T) (dualPairEquiv.symm f) := by + apply dualPairEquiv.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + rw [dualPairEquiv_map_right, LinearEquiv.apply_symm_apply] + rfl + +lemma tensorBracket_map_left (Φ : B →ₗ[ℝ] B) + (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) (s t : B ⊗[ℝ] GaugeAlgebra) : + tensorBracket ((TensorProduct.map Φ LinearMap.id) s) + ((TensorProduct.map Φ LinearMap.id) t) = + (TensorProduct.map Φ LinearMap.id) (tensorBracket s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => simp [hΦ] + | add x y hx hy => + simp only [map_add] + rw [hx, hy] + | add x y hx hy => simp [hx, hy] + +lemma tensorBracket_map_right (T : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (hT : ∀ a b, T ⁅a, b⁆ = ⁅T a, T b⁆) (s t : B ⊗[ℝ] GaugeAlgebra) : + tensorBracket ((TensorProduct.map LinearMap.id T) s) + ((TensorProduct.map LinearMap.id T) t) = + (TensorProduct.map LinearMap.id T) (tensorBracket s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => simp [hT] + | add x y hx hy => + simp only [map_add] + rw [hx, hy] + | add x y hx hy => simp [hx, hy] + +lemma tensorBracket_one_right (c : GaugeAlgebra) (s : B ⊗[ℝ] GaugeAlgebra) : + tensorBracket s ((1 : B) ⊗ₜ[ℝ] c) = + -(TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra c)) s := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b a => + rw [tensorBracket_tmul, mul_one, ← lie_skew, TensorProduct.tmul_neg] + simp + | add x y hx hy => + simp only [map_add, LinearMap.add_apply] + rw [hx, hy] + abel + +lemma tensorBracket_one_left (c : GaugeAlgebra) (t : B ⊗[ℝ] GaugeAlgebra) : + tensorBracket ((1 : B) ⊗ₜ[ℝ] c) t = + (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra c)) t := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b a => simp + | add x y hx hy => simp [hx, hy] + +/-! + +## The gauge transformation of the commutator + +-/ + +set_option maxHeartbeats 1000000 in +/-- The gauge transformation law of the commutator term: writing the field law as + `A_μ ↦ Ad₀ A_μ + c_μ` with `Ad₀` the base-point adjoint of `U₀⁻¹` and + `c_μ = mc(U⁻¹)_μ|₀` the constant Maurer–Cartan shift, bilinearity of the bracket + gives + + `⁅A_μ, A_ν⁆ ↦ Ad₀ ⁅A_μ, A_ν⁆ + ⁅Ad₀ A_μ, c_ν⁆ + ⁅c_μ, Ad₀ A_ν⁆ + ⁅c_μ, c_ν⁆`: + + the adjoint-transported commutator, two cross terms linear in the field (the + bracket against `c` acting on the dual index through `ad`), and the constant + commutator of the two Maurer–Cartan shifts. Uses that the gauge action is by + algebra homomorphisms (`gauge_mul`) and that the base-point adjoint transport is a + morphism of Lie algebras. -/ +lemma repGauge_commutator (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (commutator A μ ν φ) = + commutator A μ ν (adjointDualCoeff U⁻¹ 0 φ) + - A 0 μ (adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ ν)))) + + A 0 ν (adjointDualCoeff U⁻¹ 0 (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ μ)))) + + algebraMap ℂ B (φ ⁅JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ μ), + JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ ν)⁆) := by + -- the linear maps and constants of the transformation law + set Φ : B →ₗ[ℝ] B := (repGauge U).restrictScalars ℝ with hΦdef + set T₀ : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra := + JetGaugeAlgebra.eval.toLinearMap ∘ₗ JetGaugeAlgebra.iteratedDeriv 0 ∘ₗ + JetGaugeAlgebra.adjointMap U⁻¹ ∘ₗ JetGaugeAlgebra.ofConstant with hT₀def + set cμ : GaugeAlgebra := JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ μ) with hcμ + set cν : GaugeAlgebra := JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ ν) with hcν + set s : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm (A 0 μ) with hs + set t : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm (A 0 ν) with ht + have hcoeff : adjointDualCoeff U⁻¹ 0 = T₀.dualMap := by rw [hT₀def]; rfl + -- the base-point adjoint transport is a Lie algebra morphism + have hT₀lie : ∀ a b : GaugeAlgebra, T₀ ⁅a, b⁆ = ⁅T₀ a, T₀ b⁆ := by + intro a b + simp [hT₀def, JetGaugeAlgebra.ofConstant_lie, JetGaugeAlgebra.adjointMap_lie, + LieHom.map_lie] + -- the transformed component families in tensor form + have hfam : ∀ (ρ : Fin 1 ⊕ Fin 3), + Φ ∘ₗ A 0 ρ = A 0 ρ ∘ₗ T₀.dualMap + + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] JetGaugeAlgebra.eval (maurerCartanForm U⁻¹ ρ)) := by + intro ρ + refine LinearMap.ext fun ψ => ?_ + simp only [LinearMap.comp_apply, LinearMap.add_apply, hΦdef, + LinearMap.restrictScalars_apply] + rw [hA.repGauge_apply U ρ ψ, dualPairEquiv_one_tmul, ← hcoeff] + rfl + have hsμ : (TensorProduct.map Φ LinearMap.id) s = + (TensorProduct.map LinearMap.id T₀) s + (1 : B) ⊗ₜ[ℝ] cμ := by + rw [hs, ← symm_comp_left, hfam μ, map_add, symm_comp_right, + LinearEquiv.symm_apply_apply, hcμ] + have htν : (TensorProduct.map Φ LinearMap.id) t = + (TensorProduct.map LinearMap.id T₀) t + (1 : B) ⊗ₜ[ℝ] cν := by + rw [ht, ← symm_comp_left, hfam ν, map_add, symm_comp_right, + LinearEquiv.symm_apply_apply, hcν] + -- record the pairing identities, then make the local definitions opaque + have hcomm_pair : dualPairEquiv (tensorBracket s t) = commutator A μ ν := by + rw [hs, ht]; rfl + have hπs : dualPairEquiv s = A 0 μ := by + rw [hs]; exact dualPairEquiv.apply_symm_apply _ + have hπt : dualPairEquiv t = A 0 ν := by + rw [ht]; exact dualPairEquiv.apply_symm_apply _ + have hΦmul : ∀ b₁ b₂ : B, Φ (b₁ * b₂) = Φ b₁ * Φ b₂ := fun b₁ b₂ => + hA.gauge_mul U b₁ b₂ + clear_value Φ T₀ cμ cν s t + -- the tensor-level transformation of the bracket + have htensor : (TensorProduct.map Φ LinearMap.id) (tensorBracket s t) = + (TensorProduct.map LinearMap.id T₀) (tensorBracket s t) + - (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra cν)) + ((TensorProduct.map LinearMap.id T₀) s) + + (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra cμ)) + ((TensorProduct.map LinearMap.id T₀) t) + + (1 : B) ⊗ₜ[ℝ] ⁅cμ, cν⁆ := by + refine (tensorBracket_map_left Φ hΦmul s t).symm.trans + ((congrArg₂ (fun X Y => tensorBracket X Y) hsμ htν).trans ?_) + simp only [map_add, LinearMap.add_apply] + rw [tensorBracket_map_right T₀ hT₀lie, tensorBracket_one_right, + tensorBracket_one_left, tensorBracket_tmul, one_mul] + abel + -- read the tensor identity back through the pairing + have hread := congrArg (fun z => dualPairEquiv z φ) htensor + simp only [map_add, map_sub, LinearMap.add_apply, LinearMap.sub_apply, + dualPairEquiv_map_left, dualPairEquiv_map_right, + dualPairEquiv_one_tmul] at hread + rw [show repGauge U (commutator A μ ν φ) = Φ (dualPairEquiv (tensorBracket s t) φ) from by + rw [← hcomm_pair, hΦdef]; rfl, + hread, hcoeff, hcomm_pair, hπs, hπt] + rfl + +/-! + +## Second derivatives of the gauge field + +-/ + +/-- The dual adjoint coefficient at two derivatives: iterating + `∂ (Ad_U x) = Ad_U (∂ x) − ⁅ω(U), Ad_U x⁆` once more, the twice-derived coefficient + decomposes into the underived coefficient against `ad` of the derived Maurer–Cartan + form, and the once-derived coefficient against `ad` of the Maurer–Cartan form + itself. This is the two-derivative analogue of `adjointDualCoeff_singleton`. -/ +lemma _root_.StandardModel.adjointDualCoeff_pair (U : JetGaugeGroupI) + (ρ μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + adjointDualCoeff U (ρ ::ₘ {μ}) φ = + -adjointDualCoeff U 0 (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (JetGaugeAlgebra.deriv ρ (maurerCartanForm U μ)))) + - adjointDualCoeff U {ρ} (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (maurerCartanForm U μ))) := by + refine LinearMap.ext fun a => ?_ + have hderiv : ∀ τ : Fin 1 ⊕ Fin 3, + JetGaugeAlgebra.deriv τ (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)) = + -⁅maurerCartanForm U τ, + JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)⁆ := + fun τ => by rw [deriv_adjointMap, JetGaugeAlgebra.deriv_ofConstant, map_zero, zero_sub] + have hkey : JetGaugeAlgebra.iteratedDeriv (ρ ::ₘ {μ}) + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)) = + -⁅JetGaugeAlgebra.deriv ρ (maurerCartanForm U μ), + JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)⁆ + + ⁅maurerCartanForm U μ, ⁅maurerCartanForm U ρ, + JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)⁆⁆ := by + rw [JetGaugeAlgebra.iteratedDeriv_cons, LinearMap.comp_apply, + JetGaugeAlgebra.iteratedDeriv_singleton, hderiv μ, map_neg, + JetGaugeAlgebra.deriv_bracket, hderiv ρ, lie_neg] + abel + simp only [adjointDualCoeff, LinearMap.dualMap_apply, LinearMap.sub_apply, + LinearMap.neg_apply, LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap, + JetGaugeAlgebra.iteratedDeriv_zero, JetGaugeAlgebra.iteratedDeriv_singleton, + LinearMap.id_coe, id_eq] + rw [hkey, map_add, map_neg, LieHom.map_lie, LieHom.map_lie, LieHom.map_lie, + hderiv ρ, map_neg, LieHom.map_lie] + simp only [map_add, map_neg, LieAlgebra.ad_apply] + abel + +/-- The gauge transformation of the twice-derived symbol `∂_ρ ∂_σ A_τ`: the case + `s = ρ ::ₘ {σ}` of `gauge_apply_deriv` — the four Leibniz splittings of two + derivatives, plus the base-point value of the twice-derived Maurer–Cartan form. -/ +lemma repGauge_deriv_deriv_apply (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (ρ σ τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (A (ρ ::ₘ {σ}) τ φ) = + A (ρ ::ₘ {σ}) τ (adjointDualCoeff U⁻¹ 0 φ) + + A {ρ} τ (adjointDualCoeff U⁻¹ {σ} φ) + + A {σ} τ (adjointDualCoeff U⁻¹ {ρ} φ) + + A 0 τ (adjointDualCoeff U⁻¹ (ρ ::ₘ {σ}) φ) + + algebraMap ℂ B (φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.deriv ρ + (JetGaugeAlgebra.deriv σ (maurerCartanForm U⁻¹ τ))))) := by + have hanti₁ : ({σ} : Multiset (Fin 1 ⊕ Fin 3)).antidiagonal = + {((0 : Multiset (Fin 1 ⊕ Fin 3)), ({σ} : Multiset (Fin 1 ⊕ Fin 3))), + (({σ} : Multiset (Fin 1 ⊕ Fin 3)), (0 : Multiset (Fin 1 ⊕ Fin 3)))} := by + rw [show ({σ} : Multiset (Fin 1 ⊕ Fin 3)) = σ ::ₘ 0 from rfl, + Multiset.antidiagonal_cons, Multiset.antidiagonal_zero] + simp + have hanti : (ρ ::ₘ ({σ} : Multiset (Fin 1 ⊕ Fin 3))).antidiagonal = + {(({ρ} : Multiset (Fin 1 ⊕ Fin 3)), ({σ} : Multiset (Fin 1 ⊕ Fin 3))), + ((0 : Multiset (Fin 1 ⊕ Fin 3)), ρ ::ₘ ({σ} : Multiset (Fin 1 ⊕ Fin 3))), + (({σ} : Multiset (Fin 1 ⊕ Fin 3)), ({ρ} : Multiset (Fin 1 ⊕ Fin 3))), + (ρ ::ₘ ({σ} : Multiset (Fin 1 ⊕ Fin 3)), (0 : Multiset (Fin 1 ⊕ Fin 3)))} := by + rw [Multiset.antidiagonal_cons, hanti₁] + simp [Multiset.insert_eq_cons] + have h := hA.gauge_apply_deriv U (ρ ::ₘ {σ}) τ φ + rw [hanti] at h + simp only [Multiset.insert_eq_cons, Multiset.map_cons, Multiset.map_singleton, + Multiset.sum_cons, Multiset.sum_singleton, JetGaugeAlgebra.iteratedDeriv_cons, + LinearMap.comp_apply, JetGaugeAlgebra.iteratedDeriv_singleton] at h + refine h.trans ?_ + abel + +/-! + +## The bracket of general component families + +-/ + +/-- The bracket of two arbitrary component families, generalizing `commutator` (which + is the case of two field symbols): assemble into `B ⊗ 𝔤` by `dualPairEquiv.symm`, + bracket by `tensorBracket`, read back out as components. -/ +noncomputable def bracketFam (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + dualPairEquiv (tensorBracket (dualPairEquiv.symm f) (dualPairEquiv.symm g)) + +lemma commutator_eq_bracketFam + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) : commutator A μ ν = bracketFam (A 0 μ) (A 0 ν) := rfl + +/-- **The derived commutator family**: the `s`-derivative of the commutator term, given + by the Leibniz convolution of the derivative symbols over the multiset antidiagonal. + With the derivative symbols as primitives this convolution is the definition; for + `s = 0` it is the commutator itself (`commutatorFam_zero`). -/ +noncomputable def commutatorFam + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + (s.antidiagonal.map fun p => bracketFam (A p.1 μ) (A p.2 ν)).sum + +lemma commutatorFam_zero + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) : commutatorFam A μ ν 0 = commutator A μ ν := by + rw [commutatorFam, Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton, commutator_eq_bracketFam] + +lemma bracketFam_add_left (f₁ f₂ g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam (f₁ + f₂) g = bracketFam f₁ g + bracketFam f₂ g := by + simp only [bracketFam, map_add, LinearMap.add_apply] + +lemma bracketFam_add_right (f g₁ g₂ : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam f (g₁ + g₂) = bracketFam f g₁ + bracketFam f g₂ := by + simp only [bracketFam, map_add] + +/-- The bracket of two component families expanded through a basis of the gauge + algebra: the physicists' `f^a_{bc} f^b g^c`, with `φ⁅e_j, e_k⁆` the structure + constants contracted with the dual vector. -/ +lemma bracketFam_apply_eq_sum (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) : + bracketFam f g φ = ∑ j, ∑ k, + φ ⁅Module.Free.chooseBasis ℝ GaugeAlgebra j, + Module.Free.chooseBasis ℝ GaugeAlgebra k⁆ • + (f ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord j) * + g ((Module.Free.chooseBasis ℝ GaugeAlgebra).coord k)) := by + classical + set bv := Module.Free.chooseBasis ℝ GaugeAlgebra with hbv + have hdual : ∀ ψ : Module.Dual ℝ GaugeAlgebra, ∑ j, ψ (bv j) • bv.coord j = ψ := by + intro ψ + refine LinearMap.ext fun x => ?_ + conv_rhs => rw [← bv.sum_repr x, map_sum] + simp only [LinearMap.sum_apply, LinearMap.smul_apply, Module.Basis.coord_apply, + smul_eq_mul, map_smul] + exact Finset.sum_congr rfl fun j _ => mul_comm _ _ + have hbasis : ∀ h : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B, + dualPairEquiv.symm h = ∑ j, h (bv.coord j) ⊗ₜ[ℝ] bv j := by + intro h + apply dualPairEquiv.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun ψ => ?_ + calc h ψ = h (∑ j, ψ (bv j) • bv.coord j) := by rw [hdual] + _ = ∑ j, ψ (bv j) • h (bv.coord j) := by + rw [map_sum] + exact Finset.sum_congr rfl fun j _ => map_smul h _ _ + _ = dualPairEquiv (∑ j, h (bv.coord j) ⊗ₜ[ℝ] bv j) ψ := by simp + rw [bracketFam, hbasis f, hbasis g] + simp [tensorBracket_tmul, dualPairEquiv_tmul] + rw [Finset.sum_comm] + +/-- The bracket of families against a common Lie-algebra morphism on the dual index. -/ +lemma bracketFam_comp_dualMap (T : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (hT : ∀ a b, T ⁅a, b⁆ = ⁅T a, T b⁆) (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam (f ∘ₗ T.dualMap) (g ∘ₗ T.dualMap) = bracketFam f g ∘ₗ T.dualMap := by + refine LinearMap.ext fun φ => ?_ + show dualPairEquiv (tensorBracket (dualPairEquiv.symm (f ∘ₗ T.dualMap)) + (dualPairEquiv.symm (g ∘ₗ T.dualMap))) φ = bracketFam f g (T.dualMap φ) + rw [symm_comp_right, symm_comp_right, tensorBracket_map_right T hT, + dualPairEquiv_map_right] + rfl + +/-- `tensorBracket` is a derivation in the algebra factor: for `Δ` satisfying the + Leibniz rule on `B`, applying `Δ ⊗ id` to a bracket distributes over the two + arguments. -/ +lemma tensorBracket_map_left_derivation (Δ : B →ₗ[ℝ] B) + (hΔ : ∀ b₁ b₂, Δ (b₁ * b₂) = Δ b₁ * b₂ + b₁ * Δ b₂) (s t : B ⊗[ℝ] GaugeAlgebra) : + (TensorProduct.map Δ LinearMap.id) (tensorBracket s t) = + tensorBracket ((TensorProduct.map Δ LinearMap.id) s) t + + tensorBracket s ((TensorProduct.map Δ LinearMap.id) t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => simp [hΔ, TensorProduct.add_tmul] + | add x y hx hy => + simp only [map_add, hx, hy] + abel + | add x y hx hy => + simp only [map_add, LinearMap.add_apply, hx, hy] + abel + +/-- `tensorBracket` under a relative derivation on the Lie factor: if + `T₁ ⁅a, b⁆ = ⁅T₁ a, T₀ b⁆ + ⁅T₀ a, T₁ b⁆`, the two mixed brackets sum to the + `T₁`-image of the bracket. This is how the once-derived adjoint transport + distributes over the commutator. -/ +lemma tensorBracket_map_right_derivation (T₀ T₁ : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (hT : ∀ a b, T₁ ⁅a, b⁆ = ⁅T₁ a, T₀ b⁆ + ⁅T₀ a, T₁ b⁆) (s t : B ⊗[ℝ] GaugeAlgebra) : + tensorBracket ((TensorProduct.map LinearMap.id T₁) s) + ((TensorProduct.map LinearMap.id T₀) t) + + tensorBracket ((TensorProduct.map LinearMap.id T₀) s) + ((TensorProduct.map LinearMap.id T₁) t) = + (TensorProduct.map LinearMap.id T₁) (tensorBracket s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => simp [hT, TensorProduct.tmul_add] + | add x y hx hy => + simp only [map_add] + rw [← hx, ← hy] + abel + | add x y hx hy => + simp only [map_add, LinearMap.add_apply] + rw [← hx, ← hy] + abel + +/-- The family-level form of `tensorBracket_map_right_derivation`: a relative + derivation on the dual index distributes over the bracket of families. -/ +lemma bracketFam_dualMap_derivation (T₀ T₁ : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (hT : ∀ a b, T₁ ⁅a, b⁆ = ⁅T₁ a, T₀ b⁆ + ⁅T₀ a, T₁ b⁆) + (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam (f ∘ₗ T₁.dualMap) (g ∘ₗ T₀.dualMap) + + bracketFam (f ∘ₗ T₀.dualMap) (g ∘ₗ T₁.dualMap) = + bracketFam f g ∘ₗ T₁.dualMap := by + refine LinearMap.ext fun φ => ?_ + show dualPairEquiv (tensorBracket (dualPairEquiv.symm (f ∘ₗ T₁.dualMap)) + (dualPairEquiv.symm (g ∘ₗ T₀.dualMap))) φ + + dualPairEquiv (tensorBracket (dualPairEquiv.symm (f ∘ₗ T₀.dualMap)) + (dualPairEquiv.symm (g ∘ₗ T₁.dualMap))) φ = + bracketFam f g (T₁.dualMap φ) + rw [symm_comp_right, symm_comp_right, symm_comp_right, symm_comp_right, + ← LinearMap.add_apply, ← map_add, tensorBracket_map_right_derivation T₀ T₁ hT, + dualPairEquiv_map_right] + rfl + +set_option maxHeartbeats 1000000 in +/-- The gauge transformation of the bracket of two component families with affine + transformation laws `f ↦ f' + φ(c_f)·1` and `g ↦ g' + φ(c_g)·1`: the bracket of the + transformed families, two `ad` cross terms, and the constant bracket `⁅c_f, c_g⁆`. + Pure bilinearity, with `tensorBracket_one_left/right` computing the cross terms; + `repGauge_commutator` is the special case of two field symbols. -/ +lemma repGauge_bracketFam (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) {f g f' g' : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {cf cg : GaugeAlgebra} + (hf : ∀ ψ : Module.Dual ℝ GaugeAlgebra, + repGauge U (f ψ) = f' ψ + algebraMap ℂ B (ψ cf)) + (hg : ∀ ψ : Module.Dual ℝ GaugeAlgebra, + repGauge U (g ψ) = g' ψ + algebraMap ℂ B (ψ cg)) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (bracketFam f g φ) = + bracketFam f' g' φ + + g' (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra cf) + - f' (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra cg) + + algebraMap ℂ B (φ ⁅cf, cg⁆) := by + set Φ : B →ₗ[ℝ] B := (repGauge U).restrictScalars ℝ with hΦdef + have hΦmul : ∀ b₁ b₂ : B, Φ (b₁ * b₂) = Φ b₁ * Φ b₂ := fun b₁ b₂ => + hA.gauge_mul U b₁ b₂ + set s : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm f with hs + set t : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm g with ht + set s' : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm f' with hs' + set t' : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm g' with ht' + have hfm : (TensorProduct.map Φ LinearMap.id) s = s' + (1 : B) ⊗ₜ[ℝ] cf := by + rw [hs, hs', ← symm_comp_left, + show Φ ∘ₗ f = f' + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] cf) from + LinearMap.ext fun ψ => by + simp only [LinearMap.comp_apply, LinearMap.add_apply, hΦdef, + LinearMap.restrictScalars_apply] + rw [hf ψ, dualPairEquiv_one_tmul], + map_add, LinearEquiv.symm_apply_apply] + have hgm : (TensorProduct.map Φ LinearMap.id) t = t' + (1 : B) ⊗ₜ[ℝ] cg := by + rw [ht, ht', ← symm_comp_left, + show Φ ∘ₗ g = g' + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] cg) from + LinearMap.ext fun ψ => by + simp only [LinearMap.comp_apply, LinearMap.add_apply, hΦdef, + LinearMap.restrictScalars_apply] + rw [hg ψ, dualPairEquiv_one_tmul], + map_add, LinearEquiv.symm_apply_apply] + have hbra : dualPairEquiv (tensorBracket s t) = bracketFam f g := by + rw [hs, ht]; rfl + have hbra' : dualPairEquiv (tensorBracket s' t') = bracketFam f' g' := by + rw [hs', ht']; rfl + have hπs' : dualPairEquiv s' = f' := by + rw [hs']; exact dualPairEquiv.apply_symm_apply _ + have hπt' : dualPairEquiv t' = g' := by + rw [ht']; exact dualPairEquiv.apply_symm_apply _ + clear_value Φ s t s' t' + have htensor : (TensorProduct.map Φ LinearMap.id) (tensorBracket s t) = + tensorBracket s' t' + + (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra cf)) t' + - (TensorProduct.map LinearMap.id (LieAlgebra.ad ℝ GaugeAlgebra cg)) s' + + (1 : B) ⊗ₜ[ℝ] ⁅cf, cg⁆ := by + refine (tensorBracket_map_left Φ hΦmul s t).symm.trans + ((congrArg₂ (fun X Y => tensorBracket X Y) hfm hgm).trans ?_) + simp only [map_add, LinearMap.add_apply] + rw [tensorBracket_one_right, tensorBracket_one_left, tensorBracket_tmul, one_mul] + abel + have hread := congrArg (fun z => dualPairEquiv z φ) htensor + simp only [map_add, map_sub, LinearMap.add_apply, LinearMap.sub_apply, + dualPairEquiv_map_left, dualPairEquiv_map_right, dualPairEquiv_one_tmul] at hread + rw [show repGauge U (bracketFam f g φ) = Φ (dualPairEquiv (tensorBracket s t) φ) from by + rw [hbra, hΦdef]; rfl, + hread, hbra', hπs', hπt'] + rfl + + +/-! + +## Multiset combinatorics for iterated Leibniz sums + +The convolution sums of the iterated transformation laws are indexed by the multiset +antidiagonal. The two lemmas below are the coassociativity and cocommutativity-exchange +of this "comultiplication": a sum over splittings-of-splittings does not depend on the +grouping. Both are proven by a cons-induction with the summand universally quantified, +so that the inductive hypothesis absorbs the modified summands. + +-/ + +/-- Coassociativity of antidiagonal sums: summing over `s = u + v` and then `u = x + y` + is summing over `s = x + t` and then `t = y + v`. -/ +lemma _root_.Multiset.sum_antidiagonal_assoc {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (h : Multiset ι → Multiset ι → Multiset ι → M) : + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => h q.1 q.2 p.2).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun q => h p.1 q.1 q.2).sum).sum := by + induction s using Multiset.induction_on generalizing h with + | empty => simp + | cons κ s ih => + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq, + Multiset.sum_map_add] + rw [ih (fun x y v => h x y (κ ::ₘ v)), ih (fun x y v => h x (κ ::ₘ y) v), + ih (fun x y v => h (κ ::ₘ x) y v)] + abel + +/-- The exchange law of doubly-split antidiagonal sums: splitting `s = u + v` and then + `u = x + y`, `v = z + w` is, with the middle parts exchanged, splitting `s = u' + v'` + and then `u' = x + z`, `v' = y + w`. -/ +lemma _root_.Multiset.sum_antidiagonal_exchange {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (h : Multiset ι → Multiset ι → Multiset ι → Multiset ι → M) : + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => h q.1 q.2 r.1 r.2).sum).sum).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => h q.1 r.1 q.2 r.2).sum).sum).sum := by + induction s using Multiset.induction_on generalizing h with + | empty => simp + | cons κ s ih => + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq, + Multiset.sum_map_add] + rw [ih (fun x y z w => h x y z (κ ::ₘ w)), ih (fun x y z w => h x y (κ ::ₘ z) w), + ih (fun x y z w => h x (κ ::ₘ y) z w), ih (fun x y z w => h (κ ::ₘ x) y z w)] + abel + +/-- A multiset sum of linear maps, applied: the sum of the applications. -/ +lemma _root_.Multiset.sum_linearMap_apply {R M N : Type*} [Semiring R] [AddCommMonoid M] + [AddCommMonoid N] [Module R M] [Module R N] (S : Multiset (M →ₗ[R] N)) (x : M) : + S.sum x = (S.map fun f => f x).sum := by + induction S using Multiset.induction_on with + | empty => simp + | cons f S ih => simp [ih] + +/-- Every derived commutator term is a polynomial in derivative symbols of order at + most that of the derivative: each Leibniz splitting contributes a product of two + lower-order symbols. -/ +lemma commutatorFam_mem + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (s' : Multiset (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + commutatorFam A ν lam s' φ ∈ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ s'.card ∧ b = A p μ φ} := by + classical + rw [commutatorFam, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + have hle := Multiset.mem_antidiagonal.mp hp + rw [Function.comp_apply, bracketFam_apply_eq_sum] + refine Subalgebra.sum_mem _ fun j _ => Subalgebra.sum_mem _ fun k _ => ?_ + rw [← algebraMap_smul ℂ (φ ⁅Module.Free.chooseBasis ℝ GaugeAlgebra j, + Module.Free.chooseBasis ℝ GaugeAlgebra k⁆)] + refine Subalgebra.smul_mem _ ?_ _ + refine mul_mem + (Algebra.subset_adjoin ⟨p.1, ν, (Module.Free.chooseBasis ℝ GaugeAlgebra).coord j, ?_, rfl⟩) + (Algebra.subset_adjoin ⟨p.2, lam, (Module.Free.chooseBasis ℝ GaugeAlgebra).coord k, ?_, rfl⟩) + · exact hle ▸ Multiset.card_le_card (Multiset.le_add_right _ _) + · exact hle ▸ Multiset.card_le_card (Multiset.le_add_left _ _) + + +/-- A pure tensor against a multiset sum distributes over the sum. -/ +lemma _root_.Multiset.tmul_sum {R M N : Type*} [CommSemiring R] [AddCommMonoid M] + [AddCommMonoid N] [Module R M] [Module R N] (m : M) (S : Multiset N) : + m ⊗ₜ[R] S.sum = (S.map fun n => m ⊗ₜ[R] n).sum := by + induction S using Multiset.induction_on with + | empty => simp + | cons n S ih => simp [TensorProduct.tmul_add, ih] + +/-! + +## Iterated Leibniz expansions + +-/ + +lemma bracketFam_zero_left (g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam 0 g = 0 := by + simp [bracketFam] + +lemma bracketFam_zero_right (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam f 0 = 0 := by + simp [bracketFam] + +lemma bracketFam_sum_left (S : Multiset (Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)) + (g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + bracketFam S.sum g = (S.map fun f => bracketFam f g).sum := by + induction S using Multiset.induction_on with + | empty => simp [bracketFam_zero_left] + | cons f S ih => simp [bracketFam_add_left, ih] + +lemma bracketFam_sum_right (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (S : Multiset (Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)) : + bracketFam f S.sum = (S.map fun g => bracketFam f g).sum := by + induction S using Multiset.induction_on with + | empty => simp [bracketFam_zero_right] + | cons g S ih => simp [bracketFam_add_right, ih] + +/-! + +## The all-orders transport, coefficient, and structural identities + +-/ + +/-- The all-orders derivation property of the base-point adjoint transport: the + transport of a bracket is the antidiagonal convolution of transports, by the + iterated Leibniz rule for the jet bracket. -/ +lemma _root_.StandardModel.adjointTransport_bracket (U : JetGaugeGroupI) + (x : Multiset (Fin 1 ⊕ Fin 3)) (a b : GaugeAlgebra) : + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv x + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant ⁅a, b⁆))) = + (x.antidiagonal.map fun p => + ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a))), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant b)))⁆).sum := by + rw [JetGaugeAlgebra.ofConstant_lie, JetGaugeAlgebra.adjointMap_lie, + JetGaugeAlgebra.iteratedDeriv_bracket, map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [Function.comp_apply, LieHom.map_lie]) + +/-- `tensorBracket` under an antidiagonal family of transports on the Lie factor: + if `T x` distributes over the bracket as the antidiagonal convolution of the + `T m`, so does `id ⊗ T x` over `tensorBracket`. -/ +lemma tensorBracket_map_right_antidiagonal + (T : Multiset (Fin 1 ⊕ Fin 3) → GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (x : Multiset (Fin 1 ⊕ Fin 3)) + (hT : ∀ a b : GaugeAlgebra, T x ⁅a, b⁆ = + (x.antidiagonal.map fun p => ⁅T p.1 a, T p.2 b⁆).sum) + (s t : B ⊗[ℝ] GaugeAlgebra) : + (x.antidiagonal.map fun p => + tensorBracket ((TensorProduct.map LinearMap.id (T p.1)) s) + ((TensorProduct.map LinearMap.id (T p.2)) t)).sum = + (TensorProduct.map LinearMap.id (T x)) (tensorBracket s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => + simp only [tensorBracket_tmul, TensorProduct.map_tmul, LinearMap.id_coe, id_eq] + rw [hT, Multiset.tmul_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + simp) + | add y z hy hz => + rw [Multiset.map_congr rfl (fun p hp => by rw [map_add, map_add]), + Multiset.sum_map_add, hy, hz, ← map_add, ← map_add] + | add y z hy hz => + rw [Multiset.map_congr rfl (fun p hp => by + rw [map_add, map_add, LinearMap.add_apply]), + Multiset.sum_map_add, hy, hz, ← map_add, ← LinearMap.add_apply, ← map_add] + +/-- The bracket of families against an iterated dual adjoint coefficient: the + antidiagonal convolution — the all-orders form of `bracketFam_comp_dualMap` and + `bracketFam_dualMap_derivation`. -/ +lemma bracketFam_adjointDualCoeff (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (φ : Module.Dual ℝ GaugeAlgebra) : + bracketFam f g (adjointDualCoeff U x φ) = + (x.antidiagonal.map fun p => + bracketFam (f ∘ₗ adjointDualCoeff U p.1) (g ∘ₗ adjointDualCoeff U p.2) φ).sum := by + set T : Multiset (Fin 1 ⊕ Fin 3) → GaugeAlgebra →ₗ[ℝ] GaugeAlgebra := fun m => + JetGaugeAlgebra.eval.toLinearMap ∘ₗ JetGaugeAlgebra.iteratedDeriv m ∘ₗ + JetGaugeAlgebra.adjointMap U ∘ₗ JetGaugeAlgebra.ofConstant with hTdef + have hcoeff : ∀ m, adjointDualCoeff U m = (T m).dualMap := fun m => rfl + have hT : ∀ a b : GaugeAlgebra, T x ⁅a, b⁆ = + (x.antidiagonal.map fun p => ⁅T p.1 a, T p.2 b⁆).sum := by + intro a b + simp only [hTdef, LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + exact adjointTransport_bracket U x a b + rw [hcoeff x, + show bracketFam f g ((T x).dualMap φ) = + dualPairEquiv ((TensorProduct.map LinearMap.id (T x)) (tensorBracket + (dualPairEquiv.symm f) (dualPairEquiv.symm g))) φ from + (dualPairEquiv_map_right (T x) _ φ).symm, + ← tensorBracket_map_right_antidiagonal T x hT, map_multiset_sum, + Multiset.map_map, Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + simp only [Function.comp_apply] + rw [← symm_comp_right, ← symm_comp_right, hcoeff p.1, hcoeff p.2] + rfl + +/-- The all-orders decomposition of the dual adjoint coefficient with one extra + derivative — the generalization of `adjointDualCoeff_singleton` and + `adjointDualCoeff_pair`: differentiating the adjoint once produces minus the + bracket with the Maurer–Cartan form, and the remaining derivatives distribute over + it by the Leibniz rule. -/ +lemma _root_.StandardModel.adjointDualCoeff_cons (U : JetGaugeGroupI) + (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + adjointDualCoeff U (μ ::ₘ x) φ = + -((x.antidiagonal.map fun p => + adjointDualCoeff U p.2 (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra + (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))))).sum) := by + refine LinearMap.ext fun a => ?_ + have hkey : JetGaugeAlgebra.iteratedDeriv (μ ::ₘ x) + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a)) = + -((x.antidiagonal.map fun p => + ⁅JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U μ), + JetGaugeAlgebra.iteratedDeriv p.2 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant a))⁆).sum) := by + rw [show (μ ::ₘ x : Multiset (Fin 1 ⊕ Fin 3)) = x + {μ} from by + rw [add_comm, Multiset.singleton_add], + JetGaugeAlgebra.iteratedDeriv_add, LinearMap.comp_apply, + JetGaugeAlgebra.iteratedDeriv_singleton, deriv_adjointMap, + JetGaugeAlgebra.deriv_ofConstant, map_zero, zero_sub, map_neg, + JetGaugeAlgebra.iteratedDeriv_bracket] + simp only [adjointDualCoeff, LinearMap.dualMap_apply, LinearMap.neg_apply, + LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [hkey, map_neg, map_neg, map_multiset_sum, map_multiset_sum, + Multiset.map_map, Multiset.map_map, Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_)) + simp only [Function.comp_apply, LieHom.map_lie] + rfl + +/-- The all-orders structural equation of the Maurer–Cartan form, at the base point: + the `s`-th derivative of `∂_μ ω_ν − ∂_ν ω_μ + ⁅ω_μ, ω_ν⁆ = 0`, with the bracket + expanded by the iterated Leibniz rule. -/ +lemma _root_.StandardModel.eval_iteratedDeriv_maurerCartan_structure + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (μ ::ₘ s) (maurerCartanForm U ν)) = + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (ν ::ₘ s) (maurerCartanForm U μ)) + - (s.antidiagonal.map fun p => + ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U μ)), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (maurerCartanForm U ν))⁆).sum := by + have hconv : ∀ (κ : Fin 1 ⊕ Fin 3) (z : JetGaugeAlgebra), + JetGaugeAlgebra.iteratedDeriv s (JetGaugeAlgebra.deriv κ z) = + JetGaugeAlgebra.iteratedDeriv (κ ::ₘ s) z := by + intro κ z + rw [show (κ ::ₘ s : Multiset (Fin 1 ⊕ Fin 3)) = s + {κ} from by + rw [add_comm, Multiset.singleton_add], + JetGaugeAlgebra.iteratedDeriv_add, LinearMap.comp_apply, + JetGaugeAlgebra.iteratedDeriv_singleton] + have h0 := congrArg (fun z => JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s z)) + (maurerCartanForm_structure U μ ν) + simp only [map_add, map_sub, map_zero] at h0 + rw [hconv, hconv, JetGaugeAlgebra.iteratedDeriv_bracket, map_multiset_sum, + Multiset.map_map] at h0 + rw [Multiset.map_congr rfl (fun p hp => by rw [Function.comp_apply, LieHom.map_lie])] at h0 + refine eq_sub_of_add_eq ?_ + calc JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (μ ::ₘ s) (maurerCartanForm U ν)) + + (s.antidiagonal.map fun p => + ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U μ)), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (maurerCartanForm U ν))⁆).sum + = (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (μ ::ₘ s) (maurerCartanForm U ν)) + - JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (ν ::ₘ s) (maurerCartanForm U μ)) + + (s.antidiagonal.map fun p => + ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U μ)), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (maurerCartanForm U ν))⁆).sum) + + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (ν ::ₘ s) (maurerCartanForm U μ)) := by + abel + _ = JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (ν ::ₘ s) (maurerCartanForm U μ)) := by + rw [h0, zero_add] + +/-- Antidiagonal sums are symmetric under swapping the two parts. -/ +lemma _root_.Multiset.sum_antidiagonal_swap {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (h : Multiset ι → Multiset ι → M) : + (s.antidiagonal.map fun p => h p.1 p.2).sum = + (s.antidiagonal.map fun p => h p.2 p.1).sum := by + induction s using Multiset.induction_on generalizing h with + | empty => simp + | cons κ s ih => + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + rw [ih (fun a b => h a (κ ::ₘ b)), ih (fun a b => h (κ ::ₘ a) b)] + abel + +/-- A multiset sum of negations is the negation of the sum. -/ +lemma _root_.Multiset.sum_map_neg'' {ι M : Type*} [AddCommGroup M] + (s : Multiset ι) (f : ι → M) : + (s.map fun i => -f i).sum = -(s.map f).sum := by + induction s using Multiset.induction_on with + | empty => simp + | cons i s ih => + simp only [Multiset.map_cons, Multiset.sum_cons, ih] + abel + +/-! + +## The gauge transformation of iterated derivatives + +-/ + +/-- The `κ ::ₘ s` case of `gauge_apply_deriv` with the extra derivative traced through: + the Leibniz splittings where `κ` stays a derivative, minus (by + `adjointDualCoeff_cons`) the splittings where `κ` hits the adjoint — an `ad` of the + derived Maurer–Cartan form — plus the derived Maurer–Cartan shift. -/ +lemma repGauge_cons_apply (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (τ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (A (κ ::ₘ s) τ φ) = + (s.antidiagonal.map fun p => + A (κ ::ₘ p.2) τ (adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A p.2 τ (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 (maurerCartanForm U⁻¹ κ)))))).sum).sum + + algebraMap ℂ B (φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (κ ::ₘ s) + (maurerCartanForm U⁻¹ τ)))) := by + rw [hA.gauge_apply_deriv U (κ ::ₘ s) τ φ] + congr 1 + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + have hsec : (Multiset.map (fun p => + A p.2 τ (adjointDualCoeff U⁻¹ (κ ::ₘ p.1) φ)) s.antidiagonal).sum = + -(s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A p.2 τ (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 (maurerCartanForm U⁻¹ κ)))))).sum).sum := by + rw [← Multiset.sum_map_neg''] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [adjointDualCoeff_cons U⁻¹ κ p.1 φ, map_neg, map_multiset_sum, Multiset.map_map] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => rfl)) + rw [hsec, sub_eq_add_neg] + +set_option maxHeartbeats 2000000 in +/-- The all-orders gauge transformation of the derived commutator term: the Leibniz + convolution of the transformed commutator, the two `ad` cross-term convolutions, + and the convolution of Maurer–Cartan bracket shifts. This is `repGauge_commutator` + at every derivative order simultaneously; the regrouping of the four-fold splitting + is `Multiset.sum_antidiagonal_exchange`. -/ +lemma repGauge_commutatorFam (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (commutatorFam A μ ν s φ) = + (s.antidiagonal.map fun p => + commutatorFam A μ ν p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + A r.2 ν (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ μ)))))).sum).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A q.2 μ (adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.2 (maurerCartanForm U⁻¹ ν)))))).sum).sum + + (s.antidiagonal.map fun p => + algebraMap ℂ B (φ ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ μ)), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (maurerCartanForm U⁻¹ ν))⁆)).sum := by + -- the affine transformation law of the derived symbols, with the Leibniz sum as a map + have hAlaw : ∀ (τ : Fin 1 ⊕ Fin 3) (u : Multiset (Fin 1 ⊕ Fin 3)) + (ψ : Module.Dual ℝ GaugeAlgebra), + repGauge U (A u τ ψ) = + ((u.antidiagonal.map fun q => A q.2 τ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv u (maurerCartanForm U⁻¹ τ)))) := by + intro τ u ψ + rw [hA.gauge_apply_deriv U u τ ψ, Multiset.sum_linearMap_apply, Multiset.map_map] + congr 1 + -- the convolution triple sum in its two groupings + have hMa : (s.antidiagonal.map fun p => + bracketFam ((p.1.antidiagonal.map fun q => A q.2 μ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) + ((p.2.antidiagonal.map fun r => A r.2 ν ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) φ).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (A q.2 μ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (A r.2 ν ∘ₗ adjointDualCoeff U⁻¹ r.1) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [bracketFam_sum_left, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_) + simp only [Function.comp_apply] + rw [bracketFam_sum_right, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply] + have hMc : (s.antidiagonal.map fun p => + commutatorFam A μ ν p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (A r.1 μ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (A r.2 ν ∘ₗ adjointDualCoeff U⁻¹ q.2) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [commutatorFam, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_congr rfl (fun r hr => by + rw [Function.comp_apply, + bracketFam_adjointDualCoeff U⁻¹ p.1 (A r.1 μ) (A r.2 ν) φ]), + Multiset.sum_map_sum_map] + have hM := hMa.trans ((Multiset.sum_antidiagonal_exchange s fun a b c d => + bracketFam (A b μ ∘ₗ adjointDualCoeff U⁻¹ a) + (A d ν ∘ₗ adjointDualCoeff U⁻¹ c) φ).trans hMc.symm) + -- the cross-term sums, applied + have hCg : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + ((p.2.antidiagonal.map fun r => A r.2 ν ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ μ)))) = + (p.2.antidiagonal.map fun r => + A r.2 ν (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ μ)))))).sum := by + intro p + rw [Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply, LinearMap.coe_comp] + have hCf : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + ((p.1.antidiagonal.map fun q => A q.2 μ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.2 (maurerCartanForm U⁻¹ ν)))) = + (p.1.antidiagonal.map fun q => + A q.2 μ (adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.2 (maurerCartanForm U⁻¹ ν)))))).sum := by + intro p + rw [Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_) + simp only [Function.comp_apply, LinearMap.coe_comp] + -- expand the left side and split the four convolutions + rw [commutatorFam, Multiset.sum_linearMap_apply, Multiset.map_map, map_multiset_sum, + Multiset.map_map, + Multiset.map_congr rfl (fun p hp => by + rw [Function.comp_apply, Function.comp_apply, + hA.repGauge_bracketFam U (hAlaw μ p.1) (hAlaw ν p.2) φ, hCg p, hCf p]), + Multiset.sum_map_add, Multiset.sum_map_sub, Multiset.sum_map_add, hM] + +end IsGaugeField + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/FieldStrength.lean b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/FieldStrength.lean new file mode 100644 index 000000000..37645cf93 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/FieldStrength.lean @@ -0,0 +1,203 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.TransformsInAdjoint +public import Physlib.Particles.StandardModel.GaugeAlgebra.Basis +/-! + +# The field strength + +The field strength is defined as +``` + F_{μν} = ∂_μ A_ν − ∂_ν A_μ + ⁅A_μ, A_ν⁆ +``` +with `⁅·,·⁆` the gauge-algebra bracket, which already carries the physicists' factor +of `i` (on the matrix factors `⁅a, b⁆ = i(ab − ba)`). In terms of the plain matrix +commutator this is `F_{μν} = ∂_μ A_ν − ∂_ν A_μ + i [A_μ, A_ν]`, the sign forced by +the convention `ω_μ(g) = i (∂_μ g) g⁻¹` for the Maurer–Cartan form (equivalently, by +its structural equation `∂_μ ω_ν − ∂_ν ω_μ + ⁅ω_μ, ω_ν⁆ = 0`): only with this +coefficient do the inhomogeneous terms cancel. With the derivative symbols as +primitives the field strength is itself a family of derivative symbols +`s ↦ [∂_s F_μν]`: the derivative terms shift the multiset index, the commutator term +is the Leibniz convolution `commutatorFam`. It transforms in the adjoint at every +derivative order simultaneously (`repGauge_fieldStrength`, +`transformsInAdjoint_fieldStrength`). + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct +variable {B : Type} [Ring B] [Algebra ℂ B] + +namespace IsGaugeField + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-- The field strength `F_μν = ∂_μ A_ν − ∂_ν A_μ + ⁅A_μ, A_ν⁆` of a family of + gauge-field symbols, as a family of derivative symbols: the `s`-th derivative has + the derivative terms through the shifted symbols `A (μ ::ₘ s) ν`, the commutator + term through the Leibniz convolution `commutatorFam`. This is the physicists' + `F_μν^a = ∂_μ A_ν^a − ∂_ν A_μ^a + f^a_{bc} A_μ^b A_ν^c`: the gauge-algebra bracket + already carries the physicists' factor of `i`, so no explicit factor appears — the + same normalization as in the structural equation of the Maurer–Cartan form, which + is exactly what makes the field strength transform without inhomogeneous terms + (`repGauge_fieldStrength`). -/ +noncomputable def fieldStrength + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + A (μ ::ₘ s) ν - A (ν ::ₘ s) μ + commutatorFam A μ ν s + +@[simp] +lemma fieldStrength_apply + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + fieldStrength A μ ν s φ = A (μ ::ₘ s) ν φ - A (ν ::ₘ s) μ φ + commutatorFam A μ ν s φ := + rfl + +/-- The underived field strength: derivative symbols on singletons, plus the plain + commutator. -/ +lemma fieldStrength_zero + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (μ ν : Fin 1 ⊕ Fin 3) : + fieldStrength A μ ν 0 = A {μ} ν - A {ν} μ + commutator A μ ν := by + rw [fieldStrength, commutatorFam_zero] + rfl + +/-- The antisymmetrized pair of derivative symbols is the field strength minus its + commutator term. -/ +lemma pair_eq_fieldStrength_sub_commutatorFam + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (ν μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + A (ν ::ₘ s) μ - A (μ ::ₘ s) ν = fieldStrength A ν μ s - commutatorFam A ν μ s := by + rw [fieldStrength, add_sub_cancel_right] + + +/-- **The field strength transforms in the adjoint, at every derivative order**: under + a gauge jet `U` every derivative symbol of `F_μν` transforms by the pure Leibniz + convolution of the dual adjoint action over the multiset antidiagonal — the exact + analogue of `gauge_apply_deriv` with *no* Maurer–Cartan shift, since the field + strength transforms homogeneously. The `κ`-into-the-adjoint splittings of the + derivative terms (`repGauge_cons_apply`) cancel the `ad` cross-term convolutions of + the commutator (`repGauge_commutatorFam`) through the coassociativity and swap of + the antidiagonal, and the derived Maurer–Cartan shifts cancel the bracket-shift + convolution through the all-orders structural equation. -/ +theorem repGauge_fieldStrength (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (fieldStrength A μ ν s φ) = + (s.antidiagonal.map fun p => + fieldStrength A μ ν p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum := by + have hL : repGauge U (fieldStrength A μ ν s φ) = + repGauge U (A (μ ::ₘ s) ν φ) - repGauge U (A (ν ::ₘ s) μ φ) + + repGauge U (commutatorFam A μ ν s φ) := by + rw [fieldStrength_apply, map_add, map_sub] + have hR : (s.antidiagonal.map fun p => + fieldStrength A μ ν p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + A (μ ::ₘ p.2) ν (adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + A (ν ::ₘ p.2) μ (adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + commutatorFam A μ ν p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum := by + rw [← Multiset.sum_map_sub, ← Multiset.sum_map_add] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [fieldStrength_apply] + have hcancel₁ : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A p.2 ν (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 (maurerCartanForm U⁻¹ μ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + A r.2 ν (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ μ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + A c ν (adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv a (maurerCartanForm U⁻¹ μ)))))) + have hcancel₂ : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A p.2 μ (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 (maurerCartanForm U⁻¹ ν)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + A q.2 μ (adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.2 (maurerCartanForm U⁻¹ ν)))))).sum).sum := by + refine (Multiset.sum_antidiagonal_assoc s (fun a b c => + A c μ (adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv a (maurerCartanForm U⁻¹ ν))))))).trans ?_ + exact Multiset.sum_antidiagonal_swap s (fun a b => + (b.antidiagonal.map fun q => + A q.2 μ (adjointDualCoeff U⁻¹ q.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv a (maurerCartanForm U⁻¹ ν)))))).sum) + set Θ : GaugeAlgebra →+ B := ((algebraMap ℂ B).toAddMonoidHom.comp + ((Complex.ofRealHom : ℝ →+* ℂ).toAddMonoidHom.comp φ.toAddMonoidHom)) with hΘdef + have hΘ : ∀ z : GaugeAlgebra, algebraMap ℂ B ((φ z : ℝ) : ℂ) = Θ z := fun z => rfl + have hconst : Θ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (μ ::ₘ s) + (maurerCartanForm U⁻¹ ν))) = + Θ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv (ν ::ₘ s) + (maurerCartanForm U⁻¹ μ))) + - (s.antidiagonal.map fun p => + Θ ⁅JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ μ)), + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.2 + (maurerCartanForm U⁻¹ ν))⁆).sum := by + rw [eval_iteratedDeriv_maurerCartan_structure U⁻¹ s μ ν, map_sub, map_multiset_sum, + Multiset.map_map] + congr 1 + rw [hL, repGauge_cons_apply hA U μ s ν φ, repGauge_cons_apply hA U ν s μ φ, + hA.repGauge_commutatorFam U s μ ν φ, hR] + simp only [hΘ] + rw [hconst, hcancel₁, hcancel₂] + abel + +/-- **The field strength is an adjoint gauge tensor**: the packaging of + `repGauge_fieldStrength` as `TransformsInAdjoint` — the base case of the + covariant-derivative recursion `TransformsInAdjoint.covDerivAdjoint`. -/ +theorem transformsInAdjoint_fieldStrength (hA : IsGaugeField repLorentz repGauge A) + (μ ν : Fin 1 ⊕ Fin 3) : TransformsInAdjoint repGauge (fieldStrength A μ ν) := + fun U φ s => hA.repGauge_fieldStrength U s μ ν φ + +/-- The underived transformation law: at `s = 0` the Leibniz convolution collapses to + the homogeneous law — the field strength transforms by the base-point dual adjoint + action of `U⁻¹` on the adjoint index. -/ +lemma repGauge_fieldStrength_zero (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (fieldStrength A μ ν 0 φ) = + fieldStrength A μ ν 0 (adjointDualCoeff U⁻¹ 0 φ) := by + rw [hA.repGauge_fieldStrength U 0 μ ν φ, Multiset.antidiagonal_zero, + Multiset.map_singleton, Multiset.sum_singleton] + +/-- The transformation of the underived field strength written in the standard basis + of the gauge algebra, in terms of `adjointMatrix`: the component + `F_μν^a = F_μν(stdBasis.coord a)` transforms through the adjoint matrix of the + base-point value of `U⁻¹`, + + `U • F_μν^a = ∑ b, Ad(U₀⁻¹)^a_b F_μν^b`. -/ +lemma repGauge_fieldStrength_stdBasis (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) (a : Fin 8 ⊕ Fin 3 ⊕ Fin 1) : + repGauge U (fieldStrength A μ ν 0 (GaugeAlgebra.stdBasis.coord a)) = + ∑ b, GaugeAlgebra.adjointMatrix (U⁻¹).eval a b • + fieldStrength A μ ν 0 (GaugeAlgebra.stdBasis.coord b) := by + rw [hA.repGauge_fieldStrength_zero U μ ν, adjointDualCoeff_zero, + GaugeAlgebra.adjoint_dualMap_coord, map_sum] + simp only [map_smul] + +end IsGaugeField + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Symmeterized.lean b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Symmeterized.lean new file mode 100644 index 000000000..38bf0e58e --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/Symmeterized.lean @@ -0,0 +1,1415 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.TransformsInAdjoint +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.FieldStrength +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Truncation +public import Mathlib.LinearAlgebra.Basis.Defs +public import Mathlib.LinearAlgebra.Dimension.Free +/-! + +# The symmetrized field strength tensor + +We define the symmetrized derivatives of the gauge field as +`sym(d_s A^a_μ) := (1/(|s|+1)) ∑_{ν ∈ s+μ} d_{(s+μ)−ν} A^a_ν` +The reason for this is two fold. + +Firstly, the algebra generated by `d_s A^a_μ` is the same as the algebra generated by +`sym(d_s A^a_μ)` and `𝒟_s F^a_{μν}`. + +Secondly, while the `0`th-truncated ker gauge group acts +trivially on `𝒟_s F^a_{μν}` and all other covariant derivatives it acts freely on `sym(d_s A^a_μ)`. +This means that this group can be used to gauge away the `sym(d_s A^a_μ)`. +This free action results from the map `symmetrizedMaurerCartanCoeff` which +is itself a bijection. + +-/ + +@[expose] public section + +namespace StandardModel +namespace IsGaugeField +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] [Algebra ℂ B] + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-- The symmetrized derivative symbol `sym(d_s A)^φ`: the average over the directions + `μ ∈ s` of the symbols `d_{s−μ} A_μ^φ`, so that the direction of the gauge field is + symmetrized into the derivative multiset. -/ +noncomputable def symmetrizedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) : B := + ((1/(s.card : ℝ) : ℝ) • (s.map fun μ => A (s - {μ}) μ φ).sum) + +@[simp] +lemma symmetrizedDeriv_singleton (μ : Fin 1 ⊕ Fin 3) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) : + symmetrizedDeriv ({μ}) A φ = A 0 μ φ := by + simp [symmetrizedDeriv] + +@[simp] +lemma symmetrizedDeriv_empty + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) : + symmetrizedDeriv 0 A φ = 0 := by + simp [symmetrizedDeriv] + +lemma deriv_sub_symmetrizedDeriv_eq_sum (s : Multiset (Fin 1 ⊕ Fin 3)) + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (φ : Module.Dual ℝ GaugeAlgebra) + (μ : Fin 1 ⊕ Fin 3) : + A s μ φ - symmetrizedDeriv (μ ::ₘ s) A φ = + ((1/(s.card + 1 : ℝ)) • ((s.map fun ν => A s μ φ - + A (μ ::ₘ s - {ν}) ν φ).sum)) := by + have hn1 : (s.card : ℝ) + 1 ≠ 0 := by positivity + rw [symmetrizedDeriv, Multiset.map_cons, Multiset.sum_cons, Multiset.card_cons, + Multiset.sub_singleton, Multiset.erase_cons_head, Multiset.sum_map_sub, + Multiset.map_const', Multiset.sum_replicate, + ← Nat.cast_smul_eq_nsmul ℝ s.card, + show ((s.card + 1 : ℕ) : ℝ) = (s.card : ℝ) + 1 by push_cast; ring] + match_scalars <;> (field_simp; try ring) + +/-! + +## The generation theorem: symbols = symmetrized symbols + field strength + +The chain of lemmas below implements the outline in the module docstring, leading to + + `adjoin({ d_p A }) = adjoin({ sym(d_p A) } ∪ { 𝒟_q F })`. + +With the derivative symbols as primitives no Leibniz hypothesis is needed: the +covariant derivative of a family shifts the derivative index and adds a bracket +convolution, both of which stay inside the symbol subalgebras by construction. + +-/ + +/-- The iterated covariant derivative `𝒟_l F` of an adjoint family of derivative + symbols along a *list* of directions: covariant derivatives do not commute (their + commutator is an `ad F` term), so the iteration is order-dependent and indexed by a + list. The result is again a family of derivative symbols; the underived covariant + tower is its value at the empty multiset. -/ +noncomputable def iteratedCovDerivAdjoint + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + List (Fin 1 ⊕ Fin 3) → + (Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) → + Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B + | [], F => F + | ρ :: l, F => covDerivAdjoint A (iteratedCovDerivAdjoint A l F) ρ + +/-- Symbol subalgebras are monotone in the order bound. -/ +lemma adjoin_symbols_mono {n m : ℕ} (hnm : n ≤ m) : + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ b = A p μ φ} ≤ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ m ∧ b = A p μ φ} := by + refine Algebra.adjoin_mono fun b => ?_ + rintro ⟨p, μ, φ, h, rfl⟩ + exact ⟨p, μ, φ, h.trans hnm, rfl⟩ + +/-- The bracket of two component families whose components are order-`n` symbol + polynomials is again an order-`n` symbol polynomial, componentwise. -/ +lemma bracketFam_mem_adjoin_symbols {n : ℕ} + {f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hf : ∀ ψ, f ψ ∈ Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ}) + (hg : ∀ ψ, g ψ ∈ Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ}) + (φ : Module.Dual ℝ GaugeAlgebra) : + bracketFam f g φ ∈ Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ} := by + rw [bracketFam_apply_eq_sum] + refine Subalgebra.sum_mem _ fun j _ => Subalgebra.sum_mem _ fun k _ => ?_ + rw [← algebraMap_smul ℂ] + exact Subalgebra.smul_mem _ (mul_mem (hf _) (hg _)) _ + +/-- Every derivative symbol of the field strength is a symbol polynomial of order + one higher than the number of derivatives. -/ +lemma fieldStrength_mem_adjoin_symbols + (q : Multiset (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + fieldStrength A ν lam q φ ∈ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ q.card + 1 ∧ + b = A p μ φ} := by + rw [fieldStrength_apply] + refine add_mem (sub_mem ?_ ?_) ?_ + · exact Algebra.subset_adjoin ⟨ν ::ₘ q, lam, φ, by simp, rfl⟩ + · exact Algebra.subset_adjoin ⟨lam ::ₘ q, ν, φ, by simp, rfl⟩ + · exact adjoin_symbols_mono (Nat.le_succ q.card) + (commutatorFam_mem A q ν lam φ) + +/-- **Outline step 6** (unitriangularity of the covariant tower): the covariant and + plain derivative symbols of the field strength differ by an element of the + subalgebra generated by lower-order symbols; consequently the two towers generate + the same subalgebras. Stated at every derivative multiset `s`, as needed for the + induction: the covariant derivative shifts the family index. -/ +lemma iteratedCovDerivAdjoint_sub_mem + (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) s φ - + fieldStrength A ν lam (Multiset.ofList l + s) φ ∈ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ l.length + s.card ∧ + b = A p μ φ} := by + induction l generalizing s φ with + | nil => + simp only [iteratedCovDerivAdjoint, + show (Multiset.ofList ([] : List (Fin 1 ⊕ Fin 3))) = 0 from rfl, zero_add, + sub_self] + exact zero_mem _ + | cons ρ l ih => + have hms : Multiset.ofList (ρ :: l) + s = Multiset.ofList l + (ρ ::ₘ s) := by + rw [show Multiset.ofList (ρ :: l) = ρ ::ₘ Multiset.ofList l from rfl, + Multiset.cons_add, Multiset.add_cons] + have hsplit : iteratedCovDerivAdjoint A (ρ :: l) (fieldStrength A ν lam) s φ - + fieldStrength A ν lam (Multiset.ofList (ρ :: l) + s) φ = + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam) (ρ ::ₘ s) φ - + fieldStrength A ν lam (Multiset.ofList l + (ρ ::ₘ s)) φ) + + bracketFamConv A ρ (iteratedCovDerivAdjoint A l (fieldStrength A ν lam)) s φ := by + rw [show iteratedCovDerivAdjoint A (ρ :: l) (fieldStrength A ν lam) s φ = + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) (ρ ::ₘ s) φ + + bracketFamConv A ρ + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam)) s φ + from rfl, hms] + abel + rw [hsplit] + refine add_mem ?_ ?_ + · refine adjoin_symbols_mono ?_ (ih (ρ ::ₘ s) φ) + simp only [List.length_cons, Multiset.card_cons] + omega + · rw [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + have hle := Multiset.mem_antidiagonal.mp hp + have h1 : p.1.card ≤ s.card := + hle ▸ Multiset.card_le_card (Multiset.le_add_right _ _) + have h2 : p.2.card ≤ s.card := + hle ▸ Multiset.card_le_card (Multiset.le_add_left _ _) + refine bracketFam_mem_adjoin_symbols (fun ψ => ?_) (fun ψ => ?_) _ + · refine Algebra.subset_adjoin ⟨p.1, ρ, ψ, ?_, rfl⟩ + simp only [List.length_cons] + omega + · have h3 : iteratedCovDerivAdjoint A l (fieldStrength A ν lam) p.2 ψ = + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam) p.2 ψ - + fieldStrength A ν lam (Multiset.ofList l + p.2) ψ) + + fieldStrength A ν lam (Multiset.ofList l + p.2) ψ := by abel + rw [h3] + refine add_mem (adjoin_symbols_mono ?_ (ih p.2 ψ)) + (adjoin_symbols_mono ?_ + (fieldStrength_mem_adjoin_symbols (Multiset.ofList l + p.2) ν lam ψ)) + · simp only [List.length_cons] + omega + · simp only [Multiset.card_add, Multiset.coe_card, List.length_cons] + omega + +/-- **Outline step 7** (chaining the memberships): every derivative symbol of order + `n + 1` lies in the subalgebra generated by its symmetrization, the covariant + derivatives of the field strength of order `n`, and the symbols of order at most + `n`. This is the inductive step of the generation theorem. -/ +lemma symbol_mem_symFieldAdjoin_sup + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + A s μ φ ∈ + Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ s.card + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < s.card ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) ⊔ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ (s.card - 1) ∧ + b = A p μ φ} := by + rw [sub_eq_iff_eq_add.mp (deriv_sub_symmetrizedDeriv_eq_sum s A φ μ)] + refine add_mem ?_ ?_ + · -- the antisymmetric remainder: field strength plus lower-order terms + rw [← algebraMap_smul ℂ ((1 : ℝ)/(s.card + 1 : ℝ))] + refine Subalgebra.smul_mem _ ?_ _ + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨ν, hν, rfl⟩ := Multiset.mem_map.mp hx + have hpos : 0 < s.card := + Multiset.card_pos.mpr fun h => Multiset.notMem_zero ν (h ▸ hν) + have hcard : (s - {ν}).card = s.card - 1 := by + rw [Multiset.sub_singleton, Multiset.card_erase_of_mem hν, Nat.pred_eq_sub_one] + have hνs : ν ::ₘ (s - {ν}) = s := by + rw [Multiset.sub_singleton, Multiset.cons_erase hν] + have hμs : μ ::ₘ (s - {ν}) = μ ::ₘ s - {ν} := by + rw [Multiset.sub_singleton, Multiset.sub_singleton] + rcases eq_or_ne ν μ with rfl | h + · rw [Multiset.erase_cons_head, Multiset.cons_erase hν] + · rw [Multiset.erase_cons_tail _ h.symm] + have hpair : A s μ φ - A (μ ::ₘ s - {ν}) ν φ = + fieldStrength A ν μ (s - {ν}) φ - commutatorFam A ν μ (s - {ν}) φ := by + have h := congrArg (fun f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B => f φ) + (pair_eq_fieldStrength_sub_commutatorFam A ν μ (s - {ν})) + simp only [LinearMap.sub_apply] at h + rw [← h, hνs, hμs] + rw [hpair] + refine sub_mem ?_ ?_ + · -- the field-strength part, through the covariant tower + set l := (s - {ν}).toList with hl' + have hl : (Multiset.ofList l) = s - {ν} := Multiset.coe_toList _ + have hlen : l.length = s.card - 1 := by rw [← Multiset.coe_card, hl, hcard] + rw [show fieldStrength A ν μ (s - {ν}) φ = + iteratedCovDerivAdjoint A l (fieldStrength A ν μ) 0 φ - + (iteratedCovDerivAdjoint A l (fieldStrength A ν μ) 0 φ - + fieldStrength A ν μ (Multiset.ofList l + 0) φ) + from by rw [add_zero, hl]; abel] + refine sub_mem ?_ ?_ + · refine SetLike.le_def.mp le_sup_left + (Algebra.subset_adjoin (Or.inr ⟨l, ν, μ, φ, ?_, rfl⟩)) + omega + · refine SetLike.le_def.mp le_sup_right (adjoin_symbols_mono ?_ + (iteratedCovDerivAdjoint_sub_mem l ν μ 0 φ)) + simp only [Multiset.card_zero] + omega + · -- the commutator part is strictly lower order + refine SetLike.le_def.mp le_sup_right (adjoin_symbols_mono ?_ + (commutatorFam_mem A (s - {ν}) ν μ φ)) + omega + · -- the symmetrized symbol is a generator + exact SetLike.le_def.mp le_sup_left + (Algebra.subset_adjoin (Or.inl ⟨μ ::ₘ s, φ, Multiset.cons_ne_zero, by simp, rfl⟩)) + +/-- **The generation theorem** (outline final step, by strong induction on the + order): the derivative symbols of order at most `n` and the symmetrized symbols + together with the covariant field-strength tower generate the same subalgebra, + + `adjoin({ d_p A : |p| ≤ n }) = adjoin({ sym(d_p A) : |p| ≤ n } ∪ { 𝒟_q F : |q| < n })`. -/ +theorem symbolAdjoin_eq_symFieldAdjoin (n : ℕ) : + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ b = A p μ φ} = + Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ n + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < n ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) := by + refine le_antisymm ?_ ?_ + · -- symbols are generated by symmetrized symbols and the covariant tower, + -- by strong induction on the order + have main : ∀ m, ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ m → m ≤ n → + A p μ φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ n + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < n ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) := by + intro m + induction m using Nat.strong_induction_on with + | _ m ih => + intro p μ φ hpm hmn + have hSF : Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ p.card + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < p.card ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) ≤ + Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ n + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < n ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) := by + refine Algebra.adjoin_mono ?_ + rintro b (⟨r, ψ, h0, hc, rfl⟩ | ⟨l, ν, lam, ψ, hl, rfl⟩) + · exact Or.inl ⟨r, ψ, h0, by omega, rfl⟩ + · exact Or.inr ⟨l, ν, lam, ψ, by omega, rfl⟩ + have hAdj : Algebra.adjoin ℂ {b : B | ∃ (q : Multiset (Fin 1 ⊕ Fin 3)) + (κ : Fin 1 ⊕ Fin 3) (ψ : Module.Dual ℝ GaugeAlgebra), q.card ≤ (p.card - 1) ∧ + b = A q κ ψ} ≤ + Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ n + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < n ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) := by + refine Algebra.adjoin_le ?_ + rintro b ⟨q, κ, ψ, hqc, rfl⟩ + rcases Nat.eq_zero_or_pos q.card with hq0 | hqpos + · obtain rfl : q = 0 := Multiset.card_eq_zero.mp hq0 + refine Algebra.subset_adjoin (Or.inl ⟨{κ}, ψ, by simp, by simp, ?_⟩) + rw [symmetrizedDeriv_singleton] + · exact ih q.card (by omega) q κ ψ (le_refl _) (by omega) + exact sup_le hSF hAdj (symbol_mem_symFieldAdjoin_sup p μ φ) + refine Algebra.adjoin_le ?_ + rintro b ⟨p, μ, φ, hpc, rfl⟩ + exact main n p μ φ hpc (le_refl n) + · -- symmetrized symbols and the covariant tower are symbol polynomials + refine Algebra.adjoin_le ?_ + rintro b (⟨r, φ, hr0, hrc, rfl⟩ | ⟨l, ν, lam, φ, hl, rfl⟩) + · rw [symmetrizedDeriv, ← algebraMap_smul ℂ ((1 : ℝ)/(r.card : ℝ))] + refine Subalgebra.smul_mem _ ?_ _ + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨ν, hν, rfl⟩ := Multiset.mem_map.mp hx + refine Algebra.subset_adjoin ⟨r - {ν}, ν, φ, ?_, rfl⟩ + have : (r - {ν}).card = r.card - 1 := by + rw [Multiset.sub_singleton, Multiset.card_erase_of_mem hν, Nat.pred_eq_sub_one] + omega + · have h6 := iteratedCovDerivAdjoint_sub_mem (A := A) l ν lam 0 φ + have hF := fieldStrength_mem_adjoin_symbols (A := A) (Multiset.ofList l + 0) ν lam φ + rw [show iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ = + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ - + fieldStrength A ν lam (Multiset.ofList l + 0) φ) + + fieldStrength A ν lam (Multiset.ofList l + 0) φ + from by abel] + refine add_mem (adjoin_symbols_mono ?_ h6) (adjoin_symbols_mono ?_ hF) + · simp only [Multiset.card_zero] + omega + · simp only [Multiset.card_add, Multiset.coe_card, Multiset.card_zero] + omega + +/-- **The generation theorem, unbounded version**: the derivative symbols of the gauge + field of all orders, and the symmetrized symbols together with the full covariant + field-strength tower, generate the same subalgebra of local expressions, + + `adjoin({ d_p A }) = adjoin({ sym(d_p A) } ∪ { 𝒟_q F })`. + + It follows from the graded version `symbolAdjoin_eq_symFieldAdjoin` since every + generator on either side appears at some finite order. -/ +theorem symbolAdjoin_eq_symFieldAdjoin_top : + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), b = A p μ φ} = + Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) := by + refine le_antisymm (Algebra.adjoin_le ?_) (Algebra.adjoin_le ?_) + · rintro b ⟨p, μ, φ, rfl⟩ + have h := (symbolAdjoin_eq_symFieldAdjoin (A := A) p.card).le + (Algebra.subset_adjoin ⟨p, μ, φ, le_refl _, rfl⟩) + refine Algebra.adjoin_mono ?_ h + rintro b (⟨r, ψ, h0, _, rfl⟩ | ⟨l, ν, lam, ψ, _, rfl⟩) + · exact Or.inl ⟨r, ψ, h0, rfl⟩ + · exact Or.inr ⟨l, ν, lam, ψ, rfl⟩ + · have hmono : ∀ n : ℕ, Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ} ≤ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), b = A p μ φ} := by + intro n + refine Algebra.adjoin_mono ?_ + rintro b ⟨p, μ, ψ, _, rfl⟩ + exact ⟨p, μ, ψ, rfl⟩ + rintro b (⟨r, φ, hr0, rfl⟩ | ⟨l, ν, lam, φ, rfl⟩) + · have hcard : 1 ≤ r.card := + Nat.one_le_iff_ne_zero.mpr fun h => hr0 (Multiset.card_eq_zero.mp h) + exact hmono (r.card - 1) + ((symbolAdjoin_eq_symFieldAdjoin (A := A) (r.card - 1)).ge + (Algebra.subset_adjoin (Or.inl ⟨r, φ, hr0, by omega, rfl⟩))) + · exact hmono (l.length + 1) + ((symbolAdjoin_eq_symFieldAdjoin (A := A) (l.length + 1)).ge + (Algebra.subset_adjoin (Or.inr ⟨l, ν, lam, φ, by omega, rfl⟩))) + +/-! + +## The gauge action on the symmetrized derivatives + +-/ + +/-- **The gauge transformation of the symmetrized derivatives**: averaging the + transformation law `gauge_apply_deriv` of the individual derivative symbols over + the multiset `s`, the homogeneous part is the symmetrized adjoint convolution and + the inhomogeneous Maurer–Cartan shifts average to exactly the base-point value of + the *symmetrized Maurer–Cartan form* of `U⁻¹`: + + `U • sym(d_s A)^φ = (1/|s|) ∑_{μ ∈ s} ∑_{x+y=s−μ} d_y A_μ^{∂_x Ad*(U⁻¹) φ}` + ` + φ( sym(mc(U⁻¹))_s |₀ )`. + + This is the symbol-level counterpart of `symmetrizedMaurerCartanForm`: the gauge + group acts on the symmetrized derivative coordinates through the symmetrized + Maurer–Cartan data. -/ +lemma repGauge_symmetrizedDeriv (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (symmetrizedDeriv s A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + A p.2 μ (adjointDualCoeff U⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (JetGaugeAlgebra.eval (symmetrizedMaurerCartanForm U⁻¹ s))) := by + set L : JetGaugeAlgebra →ₗ[ℝ] B := + (Algebra.linearMap ℂ B).restrictScalars ℝ ∘ₗ Algebra.linearMap ℝ ℂ ∘ₗ + φ ∘ₗ JetGaugeAlgebra.eval.toLinearMap with hL + rw [symmetrizedDeriv, LinearMap.map_smul_of_tower, map_multiset_sum, Multiset.map_map] + simp only [Function.comp_def] + rw [Multiset.map_congr rfl (fun μ _ => hA.gauge_apply_deriv U (s - {μ}) μ φ), + Multiset.sum_map_add, smul_add] + congr 1 + calc (1/(s.card : ℝ)) • (s.map fun μ => algebraMap ℂ B (φ (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv (s - {μ}) (maurerCartanForm U⁻¹ μ))))).sum + = (1/(s.card : ℝ)) • (s.map fun μ => + L (JetGaugeAlgebra.iteratedDeriv (s - {μ}) (maurerCartanForm U⁻¹ μ))).sum := rfl + _ = L ((1/(s.card : ℝ)) • (s.map fun μ => + JetGaugeAlgebra.iteratedDeriv (s - {μ}) (maurerCartanForm U⁻¹ μ)).sum) := by + rw [map_smul, map_multiset_sum, Multiset.map_map] + simp only [Function.comp_def] + _ = algebraMap ℂ B (φ (JetGaugeAlgebra.eval (symmetrizedMaurerCartanForm U⁻¹ s))) := by + rw [symmetrizedMaurerCartanForm] + rfl + +/-- **The action of the truncation kernel on the symmetrized derivatives is through + the symmetrized Maurer–Cartan coefficients**: for a gauge jet `U` whose value at + the base point is the identity, the inhomogeneous shift of `sym(d_s A)^φ` is the + pairing of `φ` with the symmetrized Maurer–Cartan coefficient of `U⁻¹` at `s` — + the very data that classifies pure jets (`symmetrizedMaurerCartanCoeff_injective`). + This is the mechanism by which the truncation kernel can be used to gauge away the + symmetrized derivative coordinates. -/ +lemma repGauge_symmetrizedDeriv_truncationKer + (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI.truncationKer 0) (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U.1 (symmetrizedDeriv s A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + A p.2 μ (adjointDualCoeff (U.1)⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (symmetrizedMaurerCartanCoeff U⁻¹ ⟨s, hs⟩)) := by + rw [repGauge_symmetrizedDeriv hA U.1 s φ] + rfl + +/-- **The truncation kernel realizes arbitrary translations of the symmetrized + derivative coordinates**: for any prescribed family `c` of gauge-algebra values, + there is a gauge jet `U` in the kernel of the zeroth truncation whose action shifts + every symmetrized derivative symbol by exactly `φ (c s)` — by the surjectivity of + the symmetrized Maurer–Cartan coefficients. + + This is the freeness/transitivity statement behind "gauging away" the symmetrized + coordinates: since the action of `U` is invertible on `B`, no symbol is literally + sent to zero, but on any fixed field configuration (a point of `Spec B`) the shift + `c` can be chosen to cancel the configuration's symmetrized derivative values. -/ +lemma exists_repGauge_symmetrizedDeriv_shift + (hA : IsGaugeField repLorentz repGauge A) + (c : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → GaugeAlgebra) : + ∃ U : JetGaugeGroupI.truncationKer 0, + ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) (φ : Module.Dual ℝ GaugeAlgebra), + repGauge U.1 (symmetrizedDeriv s A φ) = + (1/(s.card : ℝ)) • (s.map fun μ => + ((s - {μ}).antidiagonal.map fun p => + A p.2 μ (adjointDualCoeff (U.1)⁻¹ p.1 φ)).sum).sum + + algebraMap ℂ B (φ (c ⟨s, hs⟩)) := by + obtain ⟨V, hV⟩ := symmetrizedMaurerCartanCoeff_surjective c + refine ⟨V⁻¹, fun s hs φ => ?_⟩ + rw [repGauge_symmetrizedDeriv_truncationKer hA V⁻¹ s hs φ, inv_inv, hV] + +/-! + +## Centrality of the gauge-field symbols, and invariants of the truncation kernel + +Throughout, `hc` is the hypothesis that all derivative symbols of the gauge field are +central in `B` — the statement that the gauge field is bosonic. Everything built from +the symbols by the bracket is then central as well. + +-/ + +/-- Scalars are central. -/ +lemma algebraMap_mem_center (c : ℂ) : algebraMap ℂ B c ∈ Subring.center B := + Subring.mem_center_iff.mpr fun b => (Algebra.commutes c b).symm + +/-- Real multiples of central elements are central. -/ +lemma smul_mem_center (r : ℝ) {x : B} (hx : x ∈ Subring.center B) : + r • x ∈ Subring.center B := by + rw [← algebraMap_smul ℂ r x, Algebra.smul_def] + exact Subring.mul_mem _ (algebraMap_mem_center _) hx + +/-- The bracket of component families with central components is central. -/ +lemma bracketFam_mem_center {f g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hf : ∀ ψ, f ψ ∈ Subring.center B) (hg : ∀ ψ, g ψ ∈ Subring.center B) + (φ : Module.Dual ℝ GaugeAlgebra) : + bracketFam f g φ ∈ Subring.center B := by + rw [bracketFam_apply_eq_sum] + refine Subring.sum_mem _ fun j _ => Subring.sum_mem _ fun k _ => ?_ + exact smul_mem_center _ (Subring.mul_mem _ (hf _) (hg _)) + +/-- The derived commutator terms of central symbols are central. -/ +lemma commutatorFam_mem_center + (hc : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), A p μ φ ∈ Subring.center B) + (ν lam : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra) : + commutatorFam A ν lam s φ ∈ Subring.center B := by + rw [commutatorFam, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + exact bracketFam_mem_center (fun ψ => hc _ _ _) (fun ψ => hc _ _ _) φ + +/-- **1.** If the derivative symbols of the gauge field are central, so are all + derivative symbols of the covariant derivatives of the field strength. -/ +lemma iteratedCovDerivAdjoint_fieldStrength_mem_center + (hc : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), A p μ φ ∈ Subring.center B) + (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) s φ ∈ Subring.center B := by + induction l generalizing s φ with + | nil => + show fieldStrength A ν lam s φ ∈ Subring.center B + rw [fieldStrength_apply] + exact Subring.add_mem _ + (Subring.sub_mem _ (hc _ _ _) (hc _ _ _)) + (commutatorFam_mem_center hc ν lam s φ) + | cons ρ l ih => + rw [show iteratedCovDerivAdjoint A (ρ :: l) (fieldStrength A ν lam) s φ = + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) (ρ ::ₘ s) φ + + bracketFamConv A ρ + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam)) s φ + from rfl] + refine Subring.add_mem _ (ih (ρ ::ₘ s) φ) ?_ + rw [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + exact bracketFam_mem_center (fun ψ => hc _ _ _) (fun ψ => ih p.2 ψ) φ + +/-- **2.** If the derivative symbols of the gauge field are central, so are the + symmetrized derivative symbols. -/ +lemma symmetrizedDeriv_mem_center + (hc : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), A p μ φ ∈ Subring.center B) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + symmetrizedDeriv s A φ ∈ Subring.center B := by + rw [symmetrizedDeriv] + refine smul_mem_center _ (multiset_sum_mem _ fun x hx => ?_) + obtain ⟨μ, hμ, rfl⟩ := Multiset.mem_map.mp hx + exact hc _ _ _ + +/-- **3.** Anything that transforms in the adjoint is invariant under the kernel of + the zeroth truncation: at `s = 0` the transformation law is the dual adjoint action + of the base-point value `U₀⁻¹ = 1`, which is trivial. -/ +lemma TransformsInAdjoint.repGauge_eq_of_mem_truncationKer_zero + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hF : TransformsInAdjoint repGauge F) + (U : JetGaugeGroupI.truncationKer 0) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U.1 (F 0 φ) = F 0 φ := by + have hinv : ((U.1)⁻¹).eval = 1 := by + rw [map_inv, JetGaugeGroupI.mem_truncationKer_zero_iff.mp U.2, inv_one] + simpa [adjointDualCoeff_zero_of_eval_eq_one hinv] using hF U.1 φ 0 + +/-- **Every iterated covariant derivative of the field strength is an adjoint gauge + tensor**: the recursion of `TransformsInAdjoint.covDerivAdjoint` over the list of + directions, from the base case `transformsInAdjoint_fieldStrength`. -/ +theorem transformsInAdjoint_iteratedCovDerivAdjoint + (hA : IsGaugeField repLorentz repGauge A) (l : List (Fin 1 ⊕ Fin 3)) + (ν lam : Fin 1 ⊕ Fin 3) : + TransformsInAdjoint repGauge + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam)) := by + induction l with + | nil => exact transformsInAdjoint_fieldStrength hA ν lam + | cons ρ l ih => exact TransformsInAdjoint.covDerivAdjoint hA ih ρ + +/-- **4.** The covariant derivatives of the field strength are invariant under the + kernel of the zeroth truncation: they transform in the adjoint, and the truncation + kernel acts through the trivial base-point adjoint. -/ +lemma repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero + (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI.truncationKer 0) (l : List (Fin 1 ⊕ Fin 3)) + (ν lam : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U.1 (iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ) = + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ := + (transformsInAdjoint_iteratedCovDerivAdjoint hA l ν + lam).repGauge_eq_of_mem_truncationKer_zero U φ + +/-! + +## The classification of invariants + +The goal of this section is the classification theorem: a gauge-invariant element of +the subalgebra generated by the gauge-field symbols together with a set `S` of +`truncationKer 0`-fixed elements lies in the subalgebra generated by the covariant +field-strength tower together with `S` — assuming only that the gauge-field symbols +are central (bosonic), with **no algebraic-independence hypothesis**. + +The strategy, by downward induction on the top symbol order `N` present in `x`: + +* By the generation theorem (relativized to `S`), `x` is a polynomial expression in + the symmetrized symbols of order `≤ N`, the covariant field-strength tower, and `S`. +* Using the surjectivity of the symmetrized Maurer–Cartan coefficients, choose gauge + jets whose coefficients are supported at exactly order `N`. The Maurer–Cartan + triangularity places such jets in the deep truncation kernel `truncationKer (N-1)`, + which kills all dual adjoint coefficients of positive order `< N`. Consequently + such a jet fixes every generator of order `< N`, fixes the covariant tower and `S`, + and acts on the order-`N` symmetrized symbols by a *pure translation* with an + arbitrary prescribable scalar family. +* The extraction step needs no independence: pick *any* representation of `x` as a + polynomial in the top symbols over the fixed subalgebra. Invariance under all + translations gives, for every shift vector, a polynomial identity; evaluating at + sufficiently many shifts (a Vandermonde argument — pure linear algebra in `B`, no + freeness) forces the top coefficient of *the chosen representation* to vanish, and + downward induction kills every nonconstant coefficient. Hence `x` lies in the fixed + subalgebra, completing the induction step. + +-/ + +/-- The generation theorem relativized to an arbitrary set `S` of extra generators: + a corollary of `symbolAdjoin_eq_symFieldAdjoin` since `adjoin (X ∪ S)` is + determined by `adjoin X` and `S`. -/ +theorem symbolAdjoin_union_eq_symFieldAdjoin_union (n : ℕ) (S : Set B) : + Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ} ∪ S) = + Algebra.adjoin ℂ + (({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ n + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + {b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), l.length < n ∧ + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ}) ∪ S) := by + rw [Algebra.adjoin_union, Algebra.adjoin_union, + symbolAdjoin_eq_symFieldAdjoin (A := A) n] + +/-- Finite order bound: membership in the subalgebra generated by all symbols and `S` + uses only finitely many generators, hence symbols of some bounded order. -/ +lemma exists_le_of_mem_adjoin_symbols_union (S : Set B) {x : B} + (hx : x ∈ Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + b = A p μ φ} ∪ S)) : + ∃ n : ℕ, x ∈ Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ} ∪ S) := by + have hmono : ∀ {n m : ℕ}, n ≤ m → + Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ n ∧ + b = A p μ φ} ∪ S) ≤ + Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ m ∧ + b = A p μ φ} ∪ S) := by + intro n m hnm + refine Algebra.adjoin_mono (Set.union_subset_union_left S ?_) + rintro b ⟨p, μ, φ, h, rfl⟩ + exact ⟨p, μ, φ, h.trans hnm, rfl⟩ + induction hx using Algebra.adjoin_induction with + | mem b hb => + rcases hb with ⟨p, μ, φ, rfl⟩ | hbS + · exact ⟨p.card, Algebra.subset_adjoin (Or.inl ⟨p, μ, φ, le_refl _, rfl⟩)⟩ + · exact ⟨0, Algebra.subset_adjoin (Or.inr hbS)⟩ + | algebraMap c => exact ⟨0, Subalgebra.algebraMap_mem _ c⟩ + | add u v hu hv ihu ihv => + obtain ⟨n₁, h₁⟩ := ihu + obtain ⟨n₂, h₂⟩ := ihv + exact ⟨max n₁ n₂, add_mem (hmono (le_max_left _ _) h₁) (hmono (le_max_right _ _) h₂)⟩ + | mul u v hu hv ihu ihv => + obtain ⟨n₁, h₁⟩ := ihu + obtain ⟨n₂, h₂⟩ := ihv + exact ⟨max n₁ n₂, mul_mem (hmono (le_max_left _ _) h₁) (hmono (le_max_right _ _) h₂)⟩ + +/-- **Pure translation**: when all positive dual adjoint coefficients of `U⁻¹` below + the order of `s` vanish, the adjoint convolution in the transformation of the + symmetrized symbol collapses to the symbol itself, and the action is an honest + translation by the symmetrized Maurer–Cartan coefficient. -/ +theorem repGauge_symmetrizedDeriv_translation + (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI.truncationKer 0) (s : Multiset (Fin 1 ⊕ Fin 3)) (hs : s ≠ 0) + (hU : ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card < s.card → + adjointDualCoeff (U.1)⁻¹ x = 0) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U.1 (symmetrizedDeriv s A φ) = + symmetrizedDeriv s A φ + + algebraMap ℂ B (φ (symmetrizedMaurerCartanCoeff U⁻¹ ⟨s, hs⟩)) := by + -- collapsing principle: a sum over the antidiagonal whose terms vanish off the + -- `(0, t)` splitting reduces to the `(0, t)` term + have hcollapse : ∀ (t : Multiset (Fin 1 ⊕ Fin 3)) + (g : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3) → B), + (∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + p.1 + p.2 = t → p.1 ≠ 0 → g p = 0) → + (t.antidiagonal.map g).sum = g (0, t) := by + intro t + induction t using Multiset.induction_on with + | empty => + intro g hg + simp [Multiset.antidiagonal_zero] + | cons a t ih => + intro g hg + rw [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Multiset.map_map] + have h1 : ((t.antidiagonal.map (g ∘ Prod.map (a ::ₘ ·) id)).sum) = 0 := by + refine Multiset.sum_eq_zero fun z hz => ?_ + obtain ⟨q, hq, rfl⟩ := Multiset.mem_map.mp hz + have hq' := Multiset.mem_antidiagonal.mp hq + refine hg _ ?_ (Multiset.cons_ne_zero) + show (a ::ₘ q.1) + q.2 = a ::ₘ t + rw [Multiset.cons_add, hq'] + have h2 : ((t.antidiagonal.map (g ∘ Prod.map id (a ::ₘ ·))).sum) = + g (0, a ::ₘ t) := by + rw [ih (g ∘ Prod.map id (a ::ₘ ·)) fun p hp hp1 => ?_] + · rfl + · refine hg _ ?_ hp1 + show p.1 + (a ::ₘ p.2) = a ::ₘ t + rw [Multiset.add_cons, hp] + rw [h1, h2, add_zero] + rw [repGauge_symmetrizedDeriv_truncationKer hA U s hs φ] + congr 1 + have hinv1 : ((U.1)⁻¹).eval = 1 := by + rw [map_inv, JetGaugeGroupI.eval_coe_of_mem_truncationKer_zero U, inv_one] + have hid := adjointDualCoeff_zero_of_eval_eq_one hinv1 + rw [symmetrizedDeriv] + congr 1 + refine congrArg Multiset.sum (Multiset.map_congr rfl fun μ hμ => ?_) + have hvan : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + p.1 + p.2 = s - {μ} → p.1 ≠ 0 → + A p.2 μ (adjointDualCoeff (U.1)⁻¹ p.1 φ) = 0 := by + intro p hp hp1 + have hcard : p.1.card < s.card := by + have h1 : p.1.card + p.2.card = (s - {μ}).card := by rw [← Multiset.card_add, hp] + have h2 : (s - {μ}).card = s.card - 1 := by + rw [Multiset.sub_singleton, Multiset.card_erase_of_mem hμ, Nat.pred_eq_sub_one] + have h3 : s.card ≠ 0 := fun h => hs (Multiset.card_eq_zero.mp h) + omega + rw [hU p.1 hp1 hcard] + simp + rw [hcollapse (s - {μ}) _ hvan, hid] + rfl + +/-- **Realization of top-order translations**: any coefficient family supported at + exactly order `N` is realized by a jet in the deep truncation kernel — surjectivity + of the symmetrized Maurer–Cartan coefficients together with the triangularity and + vanishing theorems above. -/ +theorem exists_translation_of_support + (N : ℕ) (c : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → GaugeAlgebra) + (hcN : ∀ r, r.1.card ≠ N → c r = 0) : + ∃ U : JetGaugeGroupI.truncationKer 0, + symmetrizedMaurerCartanCoeff U⁻¹ = c ∧ + ∀ x : Multiset (Fin 1 ⊕ Fin 3), x ≠ 0 → x.card < N → + adjointDualCoeff (U.1)⁻¹ x = 0 := by + obtain ⟨V, hV⟩ := symmetrizedMaurerCartanCoeff_surjective c + -- the realizing jet is deep in the truncation filtration, by triangularity + have hVmem : V.1 ∈ JetGaugeGroupI.truncationKer (N - 1) := by + refine mem_truncationKer_of_symmetrizedMaurerCartanCoeff_eq_zero V (N - 1) ?_ + intro r hr hrcard + rw [hV] + refine hcN ⟨r, hr⟩ ?_ + show r.card ≠ N + have hne : r.card ≠ 0 := fun h => hr (Multiset.card_eq_zero.mp h) + omega + refine ⟨V⁻¹, by rw [inv_inv, hV], fun x hx hxN => ?_⟩ + have hcoe : ((V⁻¹ : JetGaugeGroupI.truncationKer 0).1)⁻¹ = V.1 := by simp + rw [hcoe] + exact adjointDualCoeff_eq_zero_of_mem_truncationKer hVmem hx (by omega) + +/-- A `B`-valued polynomial function of one real variable that vanishes identically + has vanishing coefficients: pair with real-linear functionals, which separate + points, and use that a real polynomial vanishing everywhere is zero. -/ +lemma eq_zero_of_forall_sum_smul_pow_eq_zero {n : ℕ} {b : ℕ → B} + (h : ∀ t : ℝ, ∑ m ∈ Finset.range n, t ^ m • b m = 0) : + ∀ m ∈ Finset.range n, b m = 0 := by + intro m hm + rw [← Module.forall_dual_apply_eq_zero_iff ℝ] + intro f + have hpz : (∑ j ∈ Finset.range n, Polynomial.C (f (b j)) * Polynomial.X ^ j : + Polynomial ℝ) = 0 := by + refine Polynomial.zero_of_eval_zero _ fun t => ?_ + have h1 := congrArg f (h t) + rw [map_sum, map_zero] at h1 + rw [Polynomial.eval_finsetSum] + simp only [Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_pow, + Polynomial.eval_X] + rw [← h1] + exact Finset.sum_congr rfl fun j _ => by rw [map_smul, smul_eq_mul, mul_comm] + have hcoeff := congrArg (fun q => Polynomial.coeff q m) hpz + simp only [Polynomial.finsetSum_coeff, Polynomial.coeff_C_mul, Polynomial.coeff_X_pow, + Polynomial.coeff_zero, mul_ite, mul_one, mul_zero] at hcoeff + rwa [Finset.sum_ite_eq (Finset.range n) m (fun j => f (b j)), if_pos hm] at hcoeff + +/-- Any element of the subalgebra generated by a subalgebra `R` and a single central + element `y` is a polynomial in `y` with coefficients in `R`. -/ +lemma exists_polynomial_rep (R : Subalgebra ℂ B) (y : B) + (hy : ∀ r ∈ R, Commute r y) + {x : B} (hx : x ∈ R ⊔ Algebra.adjoin ℂ {y}) : + ∃ (n : ℕ) (r : ℕ → B), (∀ k, r k ∈ R) ∧ x = ∑ k ∈ Finset.range n, r k * y ^ k := by + classical + have hx' : x ∈ Algebra.adjoin ℂ (↑R ∪ {y}) := by + rw [Algebra.adjoin_union, Algebra.adjoin_eq] + exact hx + clear hx + -- single monomials are representable + have hmono : ∀ z : B, z ∈ R → ∀ k : ℕ, ∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ + z * y ^ k = ∑ j ∈ Finset.range n, r j * y ^ j := by + intro z hz k + refine ⟨k + 1, fun j => if j = k then z else 0, + fun j => by show (if j = k then z else 0) ∈ R; split_ifs; exacts [hz, zero_mem R], ?_⟩ + rw [Finset.sum_congr rfl fun j _ => by rw [ite_mul, zero_mul], + Finset.sum_ite_eq' (Finset.range (k + 1)) k (fun j => z * y ^ j), + if_pos (Finset.self_mem_range_succ k)] + -- representability is closed under addition + have hadd : ∀ x₁ x₂ : B, + (∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ x₁ = ∑ j ∈ Finset.range n, r j * y ^ j) → + (∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ x₂ = ∑ j ∈ Finset.range n, r j * y ^ j) → + ∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ + x₁ + x₂ = ∑ j ∈ Finset.range n, r j * y ^ j := by + rintro x₁ x₂ ⟨n₁, r₁, h₁, rfl⟩ ⟨n₂, r₂, h₂, rfl⟩ + have hext : ∀ (n m : ℕ) (r : ℕ → B), n ≤ m → + (∑ j ∈ Finset.range n, r j * y ^ j) = + ∑ j ∈ Finset.range m, (if j < n then r j else 0) * y ^ j := + fun n m r hnm => + (Finset.sum_congr rfl fun j hj => by + rw [if_pos (Finset.mem_range.mp hj)]).trans + (Finset.sum_subset (Finset.range_subset_range.mpr hnm) fun j _ hj => by + rw [if_neg fun h => hj (Finset.mem_range.mpr h), zero_mul]) + refine ⟨max n₁ n₂, + fun j => (if j < n₁ then r₁ j else 0) + (if j < n₂ then r₂ j else 0), + fun j => add_mem (by split_ifs; exacts [h₁ j, zero_mem R]) + (by split_ifs; exacts [h₂ j, zero_mem R]), ?_⟩ + rw [hext n₁ (max n₁ n₂) r₁ (le_max_left _ _), hext n₂ (max n₁ n₂) r₂ (le_max_right _ _), + ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun j _ => by rw [add_mul] + -- representability is closed under finite sums + have hsum : ∀ (κ : Type) (s : Finset κ) (f : κ → B), + (∀ i ∈ s, ∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ + f i = ∑ j ∈ Finset.range n, r j * y ^ j) → + ∃ (n : ℕ) (r : ℕ → B), (∀ j, r j ∈ R) ∧ + (∑ i ∈ s, f i) = ∑ j ∈ Finset.range n, r j * y ^ j := by + intro κ s f hf + classical + induction s using Finset.induction_on with + | empty => exact ⟨0, fun _ => 0, fun _ => zero_mem R, by simp⟩ + | insert i s his ih => + rw [Finset.sum_insert his] + exact hadd _ _ (hf i (Finset.mem_insert_self i s)) + (ih fun i' hi' => hf i' (Finset.mem_insert_of_mem hi')) + induction hx' using Algebra.adjoin_induction with + | mem b hb => + rcases hb with hbR | hby + · obtain ⟨n, r, hr, hrep⟩ := hmono b hbR 0 + exact ⟨n, r, hr, by rw [← hrep, pow_zero, mul_one]⟩ + · rw [Set.mem_singleton_iff] at hby + subst hby + obtain ⟨n, r, hr, hrep⟩ := hmono 1 (one_mem R) 1 + exact ⟨n, r, hr, by rw [← hrep, pow_one, one_mul]⟩ + | algebraMap c => + obtain ⟨n, r, hr, hrep⟩ := hmono (algebraMap ℂ B c) (Subalgebra.algebraMap_mem R c) 0 + exact ⟨n, r, hr, by rw [← hrep, pow_zero, mul_one]⟩ + | add u v hu hv ihu ihv => exact hadd u v ihu ihv + | mul u v hu hv ihu ihv => + obtain ⟨n₁, r₁, h₁, rfl⟩ := ihu + obtain ⟨n₂, r₂, h₂, rfl⟩ := ihv + rw [Finset.sum_mul_sum] + refine hsum _ _ _ fun k _ => hsum _ _ _ fun l _ => ?_ + have hcomm : y ^ k * r₂ l = r₂ l * y ^ k := + ((hy _ (h₂ l)).pow_right k).eq.symm + have hterm : (r₁ k * y ^ k) * (r₂ l * y ^ l) = (r₁ k * r₂ l) * y ^ (k + l) := by + rw [← mul_assoc, mul_assoc (r₁ k), hcomm, ← mul_assoc, mul_assoc, ← pow_add] + rw [hterm] + exact hmono _ (mul_mem (h₁ k) (h₂ l)) (k + l) + +/-- The single-variable extraction: an element of `R[y]` invariant under a family of + ring endomorphisms fixing `R` pointwise and translating the central element `y` by + arbitrary prescribable real scalars lies in `R`. Invariance forces the top + coefficient of any chosen polynomial representation to vanish, by expanding the + translated polynomial and extracting the top power of the shift. -/ +lemma mem_of_translationInvariant_single (R : Subalgebra ℂ B) (y : B) + (hy : ∀ r ∈ R, Commute r y) (Φ : ℝ → B →+* B) + (hΦR : ∀ t : ℝ, ∀ z ∈ R, Φ t z = z) + (hΦy : ∀ t : ℝ, Φ t y = y + algebraMap ℂ B (t : ℂ)) + {x : B} (hx : x ∈ R ⊔ Algebra.adjoin ℂ {y}) (hinv : ∀ t, Φ t x = x) : x ∈ R := by + -- scalars pull out of products against the algebra + have hpull : ∀ (z : ℂ) (w : B), w * algebraMap ℂ B z = z • w := fun z w => by + rw [← Algebra.commutes z w, ← Algebra.smul_def] + -- the binomial expansion of the translate of a single monomial + have hterm : ∀ (r : ℕ → B), (∀ k, r k ∈ R) → ∀ (t : ℝ) (k : ℕ), Φ t (r k * y ^ k) = + ∑ j ∈ Finset.range (k + 1), t ^ j • ((k.choose j : ℂ) • (r k * y ^ (k - j))) := by + intro r hrR t k + rw [map_mul, map_pow, hΦR t _ (hrR k), hΦy t, + Commute.add_pow ((Algebra.commute_algebraMap_left ((t : ℝ) : ℂ) y).symm) k, + Finset.mul_sum] + conv_rhs => rw [← Finset.sum_range_reflect] + simp only [Nat.add_sub_cancel] + refine Finset.sum_congr rfl fun i hi => ?_ + have hik : i ≤ k := Nat.lt_succ_iff.mp (Finset.mem_range.mp hi) + rw [Nat.choose_symm hik, Nat.sub_sub_self hik, ← map_pow, + ← map_natCast (algebraMap ℂ B) (k.choose i), mul_assoc (y ^ i), ← map_mul, + ← mul_assoc, hpull, mul_smul, ← Complex.ofReal_pow, Complex.coe_smul] + suffices h : ∀ (n : ℕ) (r : ℕ → B), (∀ k, r k ∈ R) → + (∀ t, Φ t (∑ k ∈ Finset.range n, r k * y ^ k) = ∑ k ∈ Finset.range n, r k * y ^ k) → + (∑ k ∈ Finset.range n, r k * y ^ k) ∈ R by + obtain ⟨n, r, hrR, rfl⟩ := exists_polynomial_rep R y hy hx + exact h n r hrR hinv + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro r hrR hinv + rcases n with _ | n + · simp + rcases n with _ | m + · have h1 : (∑ k ∈ Finset.range 1, r k * y ^ k) = r 0 := by + rw [Finset.sum_range_one, pow_zero, mul_one] + rw [h1] + exact hrR 0 + -- top order `m + 1 ≥ 1`: the collected coefficients of the shift powers + set b : ℕ → B := fun j => ∑ k ∈ Finset.range (m + 2), + if j ≤ k then (k.choose j : ℂ) • (r k * y ^ (k - j)) else 0 with hbdef + have hexp : ∀ t : ℝ, Φ t (∑ k ∈ Finset.range (m + 2), r k * y ^ k) = + ∑ j ∈ Finset.range (m + 2), t ^ j • b j := by + intro t + calc Φ t (∑ k ∈ Finset.range (m + 2), r k * y ^ k) + = ∑ k ∈ Finset.range (m + 2), Φ t (r k * y ^ k) := map_sum _ _ _ + _ = ∑ k ∈ Finset.range (m + 2), ∑ j ∈ Finset.range (k + 1), + t ^ j • ((k.choose j : ℂ) • (r k * y ^ (k - j))) := + Finset.sum_congr rfl fun k _ => hterm r hrR t k + _ = ∑ k ∈ Finset.range (m + 2), ∑ j ∈ Finset.range (m + 2), + (if j ≤ k then t ^ j • ((k.choose j : ℂ) • (r k * y ^ (k - j))) else 0) := by + refine Finset.sum_congr rfl fun k hk => ?_ + refine ((Finset.sum_congr rfl fun j hj => ?_).trans + (Finset.sum_subset (Finset.range_subset_range.mpr + (Nat.succ_le_succ (Nat.lt_succ_iff.mp (Finset.mem_range.mp hk)))) + fun j _ hj => if_neg fun h => + hj (Finset.mem_range.mpr (Nat.lt_succ_of_le h)))) + rw [if_pos (Nat.lt_succ_iff.mp (Finset.mem_range.mp hj))] + _ = ∑ j ∈ Finset.range (m + 2), ∑ k ∈ Finset.range (m + 2), + (if j ≤ k then t ^ j • ((k.choose j : ℂ) • (r k * y ^ (k - j))) else 0) := + Finset.sum_comm + _ = ∑ j ∈ Finset.range (m + 2), t ^ j • b j := by + refine Finset.sum_congr rfl fun j _ => ?_ + rw [hbdef] + dsimp only + rw [Finset.smul_sum] + exact Finset.sum_congr rfl fun k _ => (smul_ite_zero _ _ _).symm + have hconst : ∀ t : ℝ, ∑ j ∈ Finset.range (m + 2), t ^ j • b j = + ∑ k ∈ Finset.range (m + 2), r k * y ^ k := fun t => by rw [← hexp t, hinv t] + -- evaluate at zero to identify the constant coefficient + have hb0 : b 0 = ∑ k ∈ Finset.range (m + 2), r k * y ^ k := by + have h := hconst 0 + rwa [Finset.sum_eq_single 0 (fun j _ hj => by rw [zero_pow hj, zero_smul]) + (fun h0 => absurd (Finset.mem_range.mpr (Nat.succ_pos _)) h0), pow_zero, + one_smul] at h + -- all positive-order coefficients vanish + have hvan : ∀ j ∈ Finset.range (m + 2), (if j = 0 then 0 else b j) = 0 := by + refine eq_zero_of_forall_sum_smul_pow_eq_zero fun t => ?_ + rw [Finset.sum_range_succ' + (fun j => t ^ j • (if j = 0 then (0 : B) else b j)) (m + 1)] + simp only [Nat.succ_ne_zero, ite_false, ite_true, smul_zero, add_zero] + have h := hconst t + rw [Finset.sum_range_succ' (fun j => t ^ j • b j) (m + 1), pow_zero, one_smul, + ← hb0] at h + have h2 := congrArg (fun z => z - b 0) h + simpa using h2 + -- the top coefficient of the representation is the top `b` + have hbtop : b (m + 1) = r (m + 1) := by + have h1 : ∀ k ∈ Finset.range (m + 2), + (if m + 1 ≤ k then (k.choose (m + 1) : ℂ) • (r k * y ^ (k - (m + 1))) else 0) = + (if k = m + 1 then (k.choose (m + 1) : ℂ) • (r k * y ^ (k - (m + 1))) else 0) := by + intro k hk + have hk' := Finset.mem_range.mp hk + simp only [show (m + 1 ≤ k) ↔ k = m + 1 by omega] + rw [hbdef] + dsimp only + rw [Finset.sum_congr rfl h1, + Finset.sum_ite_eq' (Finset.range (m + 2)) (m + 1) + (fun k => (k.choose (m + 1) : ℂ) • (r k * y ^ (k - (m + 1)))), + if_pos (Finset.self_mem_range_succ _), Nat.choose_self, Nat.sub_self, pow_zero, + mul_one, Nat.cast_one, one_smul] + have hrtop : r (m + 1) = 0 := by + have h := hvan (m + 1) (Finset.self_mem_range_succ _) + rwa [if_neg (Nat.succ_ne_zero m), hbtop] at h + -- strip the top term and recurse + have hstrip : (∑ k ∈ Finset.range (m + 2), r k * y ^ k) = + ∑ k ∈ Finset.range (m + 1), r k * y ^ k := by + rw [Finset.sum_range_succ, hrtop, zero_mul, add_zero] + rw [hstrip] at hinv ⊢ + exact ih (m + 1) (Nat.lt_succ_self _) r hrR hinv + +/-- **The abstract extraction theorem** — pure ring theory, no gauge input and no + independence hypothesis: if a family of unital ring endomorphisms fixes a + subalgebra `R` pointwise and translates finitely many central elements `y i` by + arbitrary prescribable scalars, then any element of the subalgebra generated by + `R` and the `y i` that is invariant under the whole family lies in `R`. + + Proof idea: choose any representation of `x` as a polynomial in the `y i` over `R`; + invariance at sufficiently many shift vectors and a Vandermonde argument force the + nonconstant coefficients of the chosen representation to vanish, top degree first. -/ +theorem mem_of_translationInvariant {ι : Type} [Fintype ι] + (R : Subalgebra ℂ B) (y : ι → B) + (hyR : ∀ i, ∀ r ∈ R, Commute r (y i)) + (hyy : ∀ i j, Commute (y i) (y j)) + (Φ : (ι → ℝ) → (B →+* B)) + (hΦR : ∀ t, ∀ z ∈ R, Φ t z = z) + (hΦy : ∀ t i, Φ t (y i) = y i + algebraMap ℂ B (t i)) + {x : B} (hx : x ∈ R ⊔ Algebra.adjoin ℂ (Set.range y)) + (hinv : ∀ t, Φ t x = x) : + x ∈ R := by + classical + suffices h : ∀ s : Finset ι, ∀ x : B, x ∈ R ⊔ Algebra.adjoin ℂ (y '' ↑s) → + (∀ t, Φ t x = x) → x ∈ R by + refine h Finset.univ x ?_ hinv + rwa [Finset.coe_univ, Set.image_univ] + intro s + induction s using Finset.induction_on with + | empty => + intro x hx hinv + simpa [Algebra.adjoin_empty] using hx + | insert i s his ih => + intro x hx hinv + -- rearrange the generators: the coordinate `i` is adjoined last + have hxR' : x ∈ (R ⊔ Algebra.adjoin ℂ (y '' ↑s)) ⊔ Algebra.adjoin ℂ {y i} := by + have hset : (y '' ↑(insert i s) : Set B) = {y i} ∪ y '' ↑s := by + rw [Finset.coe_insert, Set.image_insert_eq, Set.insert_eq] + rwa [hset, Algebra.adjoin_union, sup_comm (Algebra.adjoin ℂ {y i}), + ← sup_assoc] at hx + -- the single-coordinate translations fix the enlarged base subalgebra + have hfix : ∀ u : ℝ, ∀ z ∈ R ⊔ Algebra.adjoin ℂ (y '' ↑s), + Φ (Pi.single i u) z = z := by + intro u z hz + rw [← Algebra.adjoin_eq R, ← Algebra.adjoin_union] at hz + induction hz using Algebra.adjoin_induction with + | mem b hb => + rcases hb with hbR | ⟨j, hj, rfl⟩ + · exact hΦR _ b hbR + · have hji : j ≠ i := fun h => his (by rw [← h]; exact Finset.mem_coe.mp hj) + rw [hΦy (Pi.single i u) j, Pi.single_eq_of_ne hji] + simp + | algebraMap c => exact hΦR _ _ (Subalgebra.algebraMap_mem R c) + | add a b _ _ iha ihb => rw [map_add, iha, ihb] + | mul a b _ _ iha ihb => rw [map_mul, iha, ihb] + have hy' : ∀ r ∈ R ⊔ Algebra.adjoin ℂ (y '' ↑s), Commute r (y i) := by + intro r hr + rw [← Algebra.adjoin_eq R, ← Algebra.adjoin_union] at hr + induction hr using Algebra.adjoin_induction with + | mem b hb => + rcases hb with hbR | ⟨j, hj, rfl⟩ + · exact hyR i b hbR + · exact hyy j i + | algebraMap c => exact Algebra.commutes c (y i) + | add a b _ _ iha ihb => exact iha.add_left ihb + | mul a b _ _ iha ihb => exact iha.mul_left ihb + have hxmid : x ∈ R ⊔ Algebra.adjoin ℂ (y '' ↑s) := + mem_of_translationInvariant_single (R ⊔ Algebra.adjoin ℂ (y '' ↑s)) (y i) hy' + (fun u => Φ (Pi.single i u)) hfix + (fun u => by rw [hΦy (Pi.single i u) i, Pi.single_eq_same]) + hxR' (fun u => hinv _) + exact ih x hxmid hinv + +/-- Commutation with a generating set extends to the generated subalgebra. -/ +lemma commute_of_mem_adjoin {X : Set B} {y : B} (hX : ∀ x ∈ X, Commute x y) + {r : B} (hr : r ∈ Algebra.adjoin ℂ X) : Commute r y := by + induction hr using Algebra.adjoin_induction with + | mem b hb => exact hX b hb + | algebraMap c => exact Algebra.commutes c y + | add a b _ _ iha ihb => exact iha.add_left ihb + | mul a b _ _ iha ihb => exact iha.mul_left ihb + +/-- Anything commuting with all gauge-field symbols commutes with the symmetrized + symbols. -/ +lemma commute_symmetrizedDeriv_right {y : B} + (hy : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), Commute y (A p μ φ)) + (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + Commute y (symmetrizedDeriv r A φ) := by + rw [symmetrizedDeriv, ← algebraMap_smul ℂ ((1 : ℝ)/(r.card : ℝ))] + refine Commute.smul_right ?_ _ + refine Commute.multiset_sum_right _ _ fun x hx => ?_ + obtain ⟨μ, hμ, rfl⟩ := Multiset.mem_map.mp hx + exact hy _ _ _ + +/-- The underived covariant field-strength tower consists of polynomials in the + gauge-field symbols. -/ +lemma iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols + (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ ∈ + Algebra.adjoin ℂ {b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A p μ ψ} := by + rw [show iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ = + (iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ - + fieldStrength A ν lam (Multiset.ofList l + 0) φ) + + fieldStrength A ν lam (Multiset.ofList l + 0) φ from by abel] + refine add_mem + (SetLike.le_def.mp (Algebra.adjoin_mono ?_) + (iteratedCovDerivAdjoint_sub_mem l ν lam 0 φ)) + (SetLike.le_def.mp (Algebra.adjoin_mono ?_) + (fieldStrength_mem_adjoin_symbols _ ν lam φ)) + · rintro b ⟨p, μ, ψ, _, rfl⟩ + exact ⟨p, μ, ψ, rfl⟩ + · rintro b ⟨p, μ, ψ, _, rfl⟩ + exact ⟨p, μ, ψ, rfl⟩ + +set_option maxHeartbeats 1000000 in +/-- **The classification of invariants**: a gauge-invariant element of the subalgebra + generated by the gauge-field symbols and a set `S` of `truncationKer 0`-fixed + elements is a polynomial in the covariant derivatives of the field strength and the + elements of `S`. Requires only that the gauge-field symbols commute with each other + (the gauge field is bosonic) and with the elements of `S` — nothing about the rest + of `B`; no independence hypothesis. -/ +theorem invariant_mem_adjoin_fieldStrength + (hA : IsGaugeField repLorentz repGauge A) + (hcomm : ∀ (p q : Multiset (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) + (φ ψ : Module.Dual ℝ GaugeAlgebra), Commute (A p μ φ) (A q ν ψ)) + (S : Set B) + (hcS : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), ∀ y ∈ S, Commute y (A p μ φ)) + (hS : ∀ y ∈ S, ∀ U : JetGaugeGroupI.truncationKer 0, repGauge U.1 y = y) + {x : B} + (hx : x ∈ Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + b = A p μ φ} ∪ S)) + (hinv : ∀ U : JetGaugeGroupI, repGauge U x = x) : + x ∈ Algebra.adjoin ℂ ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S) := by + classical + -- every element of the covariant tower together with `S` is fixed by the + -- truncation kernel + have hS' : ∀ y ∈ ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S), + ∀ U : JetGaugeGroupI.truncationKer 0, repGauge U.1 y = y := by + rintro y (⟨l, ν, lam, φ, rfl⟩ | hyS) U + · exact repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero + hA U l ν lam φ + · exact hS y hyS U + -- the gauge action preserves the unit, hence acts by ring endomorphisms + have hone : ∀ U : JetGaugeGroupI, repGauge U (1 : B) = 1 := by + intro U + have h2 : repGauge U (repGauge U⁻¹ (1 : B)) = 1 := by + have h3 : repGauge U * repGauge U⁻¹ = 1 := by + rw [← map_mul, mul_inv_cancel, map_one] + calc repGauge U (repGauge U⁻¹ (1 : B)) = (repGauge U * repGauge U⁻¹) (1 : B) := rfl + _ = 1 := by rw [h3]; rfl + have h1 := hA.gauge_mul U (repGauge U⁻¹ (1 : B)) 1 + rw [mul_one, h2, one_mul] at h1 + exact h1.symm + -- the descent: invariance strips the top symmetrized order + have hdescent : ∀ (m : ℕ) (z : B), + z ∈ Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ m + 1 ∧ b = symmetrizedDeriv r A φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) → + (∀ U : JetGaugeGroupI.truncationKer 0, repGauge U.1 z = z) → + z ∈ Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ m ∧ b = symmetrizedDeriv r A φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) := by + intro m z hz hzinv + set bv := Module.Free.chooseBasis ℝ GaugeAlgebra with hbv + set R₀ : Subalgebra ℂ B := Algebra.adjoin ℂ + ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + r ≠ 0 ∧ r.card ≤ m ∧ b = symmetrizedDeriv r A φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) with hR₀ + set Y : Sym (Fin 1 ⊕ Fin 3) (m + 1) × Module.Free.ChooseBasisIndex ℝ GaugeAlgebra → B := + fun p => symmetrizedDeriv (p.1 : Multiset (Fin 1 ⊕ Fin 3)) A (bv.coord p.2) + with hYdef + -- the translating jets realizing an arbitrary top-order shift + have hUt' : ∀ t : Sym (Fin 1 ⊕ Fin 3) (m + 1) × + Module.Free.ChooseBasisIndex ℝ GaugeAlgebra → ℝ, + ∃ U : JetGaugeGroupI.truncationKer 0, + symmetrizedMaurerCartanCoeff U⁻¹ = (fun r => + if h : Multiset.card r.1 = m + 1 then ∑ j, t (⟨r.1, h⟩, j) • bv j else 0) ∧ + ∀ x' : Multiset (Fin 1 ⊕ Fin 3), x' ≠ 0 → x'.card < m + 1 → + adjointDualCoeff (U.1)⁻¹ x' = 0 := + fun t => exists_translation_of_support (m + 1) _ (fun r hr => dif_neg hr) + choose Ut hUt1 hUt2 using hUt' + -- the family of ring endomorphisms + set Φ : (Sym (Fin 1 ⊕ Fin 3) (m + 1) × + Module.Free.ChooseBasisIndex ℝ GaugeAlgebra → ℝ) → B →+* B := + fun t => + { toFun := repGauge (Ut t).1 + map_one' := hone (Ut t).1 + map_mul' := hA.gauge_mul (Ut t).1 + map_zero' := map_zero _ + map_add' := fun a b => map_add _ a b } with hΦdef + -- the endomorphisms fix the lower-order subalgebra pointwise + have hfixR₀ : ∀ t, ∀ w ∈ R₀, Φ t w = w := by + intro t w hw + rw [hR₀] at hw + induction hw using Algebra.adjoin_induction with + | mem b hb => + show repGauge (Ut t).1 b = b + rcases hb with ⟨r, φ, hr0, hrm, rfl⟩ | hb' + · have hUvan : ∀ x' : Multiset (Fin 1 ⊕ Fin 3), x' ≠ 0 → x'.card < r.card → + adjointDualCoeff ((Ut t).1)⁻¹ x' = 0 := + fun x' hx' hxc => hUt2 t x' hx' (by omega) + rw [repGauge_symmetrizedDeriv_translation hA (Ut t) r hr0 hUvan φ] + have hshift : symmetrizedMaurerCartanCoeff (Ut t)⁻¹ ⟨r, hr0⟩ = 0 := by + simp only [hUt1 t] + exact dif_neg (show ¬ Multiset.card r = m + 1 by omega) + rw [hshift, map_zero] + simp + · exact hS' b hb' (Ut t) + | algebraMap c => + show repGauge (Ut t).1 (algebraMap ℂ B c) = algebraMap ℂ B c + rw [Algebra.algebraMap_eq_smul_one, map_smul, hone] + | add a b _ _ iha ihb => rw [map_add, iha, ihb] + | mul a b _ _ iha ihb => rw [map_mul, iha, ihb] + -- the endomorphisms translate the top-order coordinates by the prescribed shifts + have hΦy : ∀ t p, Φ t (Y p) = Y p + algebraMap ℂ B ((t p : ℝ) : ℂ) := by + rintro t ⟨ps, j⟩ + have hps : Multiset.card (ps : Multiset (Fin 1 ⊕ Fin 3)) = m + 1 := + Sym.card_coe (s := ps) + have hp0 : (ps : Multiset (Fin 1 ⊕ Fin 3)) ≠ 0 := by + intro h + rw [h] at hps + simp at hps + have hUvan : ∀ x' : Multiset (Fin 1 ⊕ Fin 3), x' ≠ 0 → + x'.card < (ps : Multiset (Fin 1 ⊕ Fin 3)).card → + adjointDualCoeff ((Ut t).1)⁻¹ x' = 0 := + fun x' hx' hxc => hUt2 t x' hx' (by omega) + have hval : bv.coord j (symmetrizedMaurerCartanCoeff (Ut t)⁻¹ + ⟨(ps : Multiset (Fin 1 ⊕ Fin 3)), hp0⟩) = t (ps, j) := by + have hcoeff : symmetrizedMaurerCartanCoeff (Ut t)⁻¹ + ⟨(ps : Multiset (Fin 1 ⊕ Fin 3)), hp0⟩ = ∑ j', t (ps, j') • bv j' := by + simp only [hUt1 t] + rw [dif_pos hps] + exact Finset.sum_congr rfl fun j' _ => + congrArg (fun q : Sym (Fin 1 ⊕ Fin 3) (m + 1) => t (q, j') • bv j') + (Sym.ext rfl) + rw [hcoeff, map_sum] + simp only [map_smul, Module.Basis.coord_apply, Module.Basis.repr_self, + Finsupp.single_apply, smul_eq_mul, mul_ite, mul_one, mul_zero] + rw [Finset.sum_ite_eq' Finset.univ j (fun j' => t (ps, j'))] + simp + show repGauge (Ut t).1 (symmetrizedDeriv (ps : Multiset (Fin 1 ⊕ Fin 3)) A + (bv.coord j)) = symmetrizedDeriv (ps : Multiset (Fin 1 ⊕ Fin 3)) A + (bv.coord j) + algebraMap ℂ B ((t (ps, j) : ℝ) : ℂ) + rw [repGauge_symmetrizedDeriv_translation hA (Ut t) _ hp0 hUvan (bv.coord j), hval] + -- the coordinate expansion of a top-order symmetrized symbol in the chosen basis + have hdual : ∀ ψ : Module.Dual ℝ GaugeAlgebra, ∑ j, ψ (bv j) • bv.coord j = ψ := by + intro ψ + refine LinearMap.ext fun v => ?_ + conv_rhs => rw [← bv.sum_repr v, map_sum] + simp only [LinearMap.sum_apply, LinearMap.smul_apply, Module.Basis.coord_apply, + smul_eq_mul, map_smul] + exact Finset.sum_congr rfl fun j _ => mul_comm _ _ + have hexpand : ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra), + symmetrizedDeriv r A φ = + ∑ j, φ (bv j) • symmetrizedDeriv r A (bv.coord j) := by + intro r φ + set L : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + { toFun := fun ψ => symmetrizedDeriv r A ψ, + map_add' := fun ψ ψ' => by + simp only [symmetrizedDeriv, map_add] + rw [← smul_add, ← Multiset.sum_map_add] + map_smul' := fun c ψ => by + simp only [symmetrizedDeriv, map_smul, RingHom.id_apply] + rw [show (r.map fun μ => c • A (r - {μ}) μ ψ) = + (r.map fun μ => A (r - {μ}) μ ψ).map (fun w => c • w) from + (Multiset.map_map _ _ _).symm, + ← Multiset.smul_sum, smul_comm] } with hL + have hLcalc : L φ = ∑ j, φ (bv j) • L (bv.coord j) := by + conv_lhs => rw [← hdual φ, map_sum] + exact Finset.sum_congr rfl fun j _ => by rw [map_smul] + exact hLcalc + -- the invariant lies in the sup of the lower-order subalgebra and the coordinates + have hzsup : z ∈ R₀ ⊔ Algebra.adjoin ℂ (Set.range Y) := by + refine Algebra.adjoin_le ?_ hz + rintro b (⟨r, φ, hr0, hrm1, rfl⟩ | hb) + · by_cases hcm : r.card ≤ m + · exact SetLike.le_def.mp le_sup_left + (Algebra.subset_adjoin (Or.inl ⟨r, φ, hr0, hcm, rfl⟩)) + · have hcard : Multiset.card r = m + 1 := by omega + rw [hexpand r φ] + refine Subalgebra.sum_mem _ fun j _ => ?_ + rw [← algebraMap_smul ℂ (φ (bv j))] + refine Subalgebra.smul_mem _ ?_ _ + exact SetLike.le_def.mp le_sup_right + (Algebra.subset_adjoin ⟨(⟨r, hcard⟩, j), rfl⟩) + · exact SetLike.le_def.mp le_sup_left (Algebra.subset_adjoin (Or.inr hb)) + -- the commutation data: symbols commute with each other, the tower, and `S` + have hsymbSD : ∀ (a : Multiset (Fin 1 ⊕ Fin 3)) (b : Fin 1 ⊕ Fin 3) + (c : Module.Dual ℝ GaugeAlgebra) (r : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra), + Commute (A a b c) (symmetrizedDeriv r A φ) := + fun a b c r φ => commute_symmetrizedDeriv_right + (fun p' μ' φ' => hcomm a p' b μ' c φ') r φ + have hsymbY : ∀ (a : Multiset (Fin 1 ⊕ Fin 3)) (b : Fin 1 ⊕ Fin 3) + (c : Module.Dual ℝ GaugeAlgebra) (p), Commute (A a b c) (Y p) := + fun a b c p => hsymbSD a b c (p.1 : Multiset (Fin 1 ⊕ Fin 3)) (bv.coord p.2) + have hYY : ∀ p q, Commute (Y p) (Y q) := + fun p q => commute_symmetrizedDeriv_right + (fun p' μ' φ' => (hsymbSD p' μ' φ' (p.1 : Multiset (Fin 1 ⊕ Fin 3)) + (bv.coord p.2)).symm) (q.1 : Multiset (Fin 1 ⊕ Fin 3)) (bv.coord q.2) + have hRY : ∀ p, ∀ r ∈ R₀, Commute r (Y p) := by + intro p r hr + rw [hR₀] at hr + refine commute_of_mem_adjoin ?_ hr + rintro b (⟨r', φ', hr0, hrm, rfl⟩ | (⟨l, ν, lam, φ', rfl⟩ | hbS)) + · exact commute_symmetrizedDeriv_right + (fun p' μ' φ'' => (hsymbSD p' μ' φ'' r' φ').symm) + (p.1 : Multiset (Fin 1 ⊕ Fin 3)) (bv.coord p.2) + · exact commute_of_mem_adjoin + (fun x hx => by + obtain ⟨a, b2, c, rfl⟩ := hx + exact hsymbY a b2 c p) + (iteratedCovDerivAdjoint_fieldStrength_mem_adjoin_symbols l ν lam φ') + · exact commute_symmetrizedDeriv_right + (fun p' μ' φ' => hcS p' μ' φ' b hbS) + (p.1 : Multiset (Fin 1 ⊕ Fin 3)) (bv.coord p.2) + -- extraction: the invariant lies in the lower-order subalgebra + have hzR₀ : z ∈ R₀ := + mem_of_translationInvariant R₀ Y hRY hYY Φ hfixR₀ hΦy hzsup + (fun t => hzinv (Ut t)) + rw [hR₀] at hzR₀ + exact hzR₀ + -- bound the symbol order of the invariant, working relative to the full tower + have hxS' : x ∈ Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) + (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + b = A p μ φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) := + Algebra.adjoin_mono (Set.union_subset_union_right _ Set.subset_union_right) hx + obtain ⟨n, hxn⟩ := exists_le_of_mem_adjoin_symbols_union _ hxS' + -- convert bounded symbols to symmetrized symbols, absorbing the tower + have hconv : ∀ (k : ℕ) (z : B), + z ∈ Algebra.adjoin ℂ ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), p.card ≤ k ∧ + b = A p μ φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) → + z ∈ Algebra.adjoin ℂ ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra), r ≠ 0 ∧ r.card ≤ k + 1 ∧ + b = symmetrizedDeriv r A φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) := by + intro k z hzk + rw [symbolAdjoin_union_eq_symFieldAdjoin_union k + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)] at hzk + refine Algebra.adjoin_mono ?_ hzk + rintro b ((⟨r, φ, h0, hcr, rfl⟩ | ⟨l, ν, lam, φ, _, rfl⟩) | hb) + · exact Or.inl ⟨r, φ, h0, hcr, rfl⟩ + · exact Or.inr (Or.inl ⟨l, ν, lam, φ, rfl⟩) + · exact Or.inr hb + -- iterate the descent from the top order down to zero + have hiter : ∀ (k : ℕ) (z : B), + z ∈ Algebra.adjoin ℂ ({b : B | ∃ (r : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra), r ≠ 0 ∧ r.card ≤ k ∧ + b = symmetrizedDeriv r A φ} ∪ + ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S)) → + (∀ U : JetGaugeGroupI.truncationKer 0, repGauge U.1 z = z) → + z ∈ Algebra.adjoin ℂ ({b : B | ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = iteratedCovDerivAdjoint A l (fieldStrength A ν lam) 0 φ} ∪ S) := by + intro k + induction k with + | zero => + intro z hz0 _ + refine Algebra.adjoin_mono ?_ hz0 + rintro b (⟨r, φ, hr0, hrc, rfl⟩ | hb) + · exact absurd (Multiset.card_eq_zero.mp (Nat.le_zero.mp hrc)) hr0 + · exact hb + | succ k ih => + intro z hzk hzinv + exact ih z (hdescent k z hzk hzinv) hzinv + exact hiter (n + 1) x (hconv n x hxn) fun U => hinv U.1 + +end IsGaugeField + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/TransformsInAdjoint.lean b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/TransformsInAdjoint.lean new file mode 100644 index 000000000..93d369b4b --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/AlgebraValued/TransformsInAdjoint.lean @@ -0,0 +1,261 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Basic +/-! + +# Adjoint gauge tensors and the covariant derivative + +A family of derivative symbols is an *adjoint gauge tensor* when all its symbols +transform by the pure Leibniz convolution of the dual adjoint action, with no +inhomogeneous term. The convolution is forced: the gauge group acts on the +derivative symbols by substitution and the chain rule, so `U • [∂_s F^φ]` produces +every splitting `s = x + y` — `x` derivatives hitting the adjoint, `y` remaining on +`F`; the naive law `U • [∂_s F^φ] = F^{(∂_s Ad)^* φ}` holds only at `s = 0`. + +The two theorems of this section: the field strength is an adjoint gauge tensor +(`transformsInAdjoint_fieldStrength`), and adjoint gauge tensors are closed under +the covariant derivative `∇_ρ F = [∂_ρ F] + ⁅A_ρ, F⁆` +(`TransformsInAdjoint.covDerivAdjoint`) — so by recursion every iterated covariant +derivative of the field strength is an adjoint gauge tensor. + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct +variable {B : Type} [Ring B] [Algebra ℂ B] + +namespace IsGaugeField + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-- A family of derivative symbols `F` *transforms in the adjoint* (is an adjoint gauge + tensor) for the gauge representation `repGauge` when each symbol `[∂_s F^φ]` + transforms by the Leibniz convolution of the dual adjoint coefficients against lower + symbols — the shape of `gauge_apply_deriv` with no Maurer–Cartan shift. At `s = 0` + this is the homogeneous law `U • F^φ = F^{Ad₀^* φ}`. -/ +def TransformsInAdjoint (repGauge : Representation ℂ JetGaugeGroupI B) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : Prop := + ∀ (U : JetGaugeGroupI) (φ : Module.Dual ℝ GaugeAlgebra) (s : Multiset (Fin 1 ⊕ Fin 3)), + repGauge U (F s φ) = + (s.antidiagonal.map fun p => F p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum + +/-- **The derived bracket family** `⁅A_ρ, F⁆`: the `s`-derivative of the bracket of the + gauge field against a family, given by the Leibniz convolution of the derivative + symbols over the multiset antidiagonal. -/ +noncomputable def bracketFamConv + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (ρ : Fin 1 ⊕ Fin 3) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (s : Multiset (Fin 1 ⊕ Fin 3)) : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + (s.antidiagonal.map fun p => bracketFam (A p.1 ρ) (F p.2)).sum + +/-- The covariant derivative `∇_ρ F = [∂_ρ F] + ⁅A_ρ, F⁆` of an adjoint-valued family + of derivative symbols: the extra derivative on the symbol plus the derived bracket + against the gauge field. The gauge-algebra bracket carries the physicists' `i`, so + in matrix terms this is `∂_ρ F + i [A_ρ, F]` — the adjoint-representation covariant + derivative in the same `D = ∂ + i A` convention as the field strength. It preserves + `TransformsInAdjoint` (`TransformsInAdjoint.covDerivAdjoint`). -/ +noncomputable def covDerivAdjoint + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + F (ρ ::ₘ s) + bracketFamConv A ρ F s + +@[simp] +lemma covDerivAdjoint_apply + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℝ GaugeAlgebra) : + covDerivAdjoint A F ρ s φ = F (ρ ::ₘ s) φ + bracketFamConv A ρ F s φ := rfl + +/-! + +## The iterated covariance of the covariant derivative + +-/ + +/-- If `F` transforms in the adjoint, so do its `κ ::ₘ s`-derived symbols with the + extra derivative traced through `adjointDualCoeff_cons`: the Leibniz splittings + where `κ` stays a derivative, minus the convolution where `κ` hits the adjoint — + an `ad` of the derived Maurer–Cartan form. -/ +lemma TransformsInAdjoint.repGauge_cons + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hF : TransformsInAdjoint repGauge F) + (U : JetGaugeGroupI) (κ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (F (κ ::ₘ s) φ) = + (s.antidiagonal.map fun p => + F (κ ::ₘ p.2) (adjointDualCoeff U⁻¹ p.1 φ)).sum + - (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ κ)))))).sum).sum := by + rw [hF U φ (κ ::ₘ s)] + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + have hsec : (Multiset.map (fun p => + F p.2 (adjointDualCoeff U⁻¹ (κ ::ₘ p.1) φ)) s.antidiagonal).sum = + -(s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ κ)))))).sum).sum := by + rw [← Multiset.sum_map_neg''] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [adjointDualCoeff_cons U⁻¹ κ p.1 φ, map_neg, map_multiset_sum, Multiset.map_map] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => rfl)) + rw [hsec, sub_eq_add_neg] + +set_option maxHeartbeats 2000000 in +/-- The all-orders gauge transformation of the derived bracket `⁅A_ρ, F⁆` against an + adjoint gauge tensor `F`: since `F` transforms homogeneously, only one `ad` + cross-term convolution survives — the analogue of `repGauge_commutatorFam` + with a gauge tensor in the second slot. -/ +lemma TransformsInAdjoint.repGauge_bracketFamConv + (hA : IsGaugeField repLorentz repGauge A) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hF : TransformsInAdjoint repGauge F) + (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) (ρ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + repGauge U (bracketFamConv A ρ F s φ) = + (s.antidiagonal.map fun p => + bracketFamConv A ρ F p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum := by + have hAlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ GaugeAlgebra), + repGauge U (A u ρ ψ) = + ((u.antidiagonal.map fun q => A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) ψ + + algebraMap ℂ B (ψ (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv u (maurerCartanForm U⁻¹ ρ)))) := by + intro u ψ + rw [hA.gauge_apply_deriv U u ρ ψ, Multiset.sum_linearMap_apply, Multiset.map_map] + congr 1 + have hFlaw : ∀ (u : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ GaugeAlgebra), + repGauge U (F u ψ) = + ((u.antidiagonal.map fun r => F r.2 ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) ψ + + algebraMap ℂ B (ψ (0 : GaugeAlgebra)) := by + intro u ψ + rw [hF U ψ u, Multiset.sum_linearMap_apply, Multiset.map_map] + simp only [map_zero, Complex.ofReal_zero, add_zero] + congr 1 + have hMa : (s.antidiagonal.map fun p => + bracketFam ((p.1.antidiagonal.map fun q => A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1).sum) + ((p.2.antidiagonal.map fun r => F r.2 ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) φ).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (A q.2 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ adjointDualCoeff U⁻¹ r.1) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [bracketFam_sum_left, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => ?_) + simp only [Function.comp_apply] + rw [bracketFam_sum_right, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply] + have hMc : (s.antidiagonal.map fun p => + bracketFamConv A ρ F p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + (p.2.antidiagonal.map fun r => + bracketFam (A r.1 ρ ∘ₗ adjointDualCoeff U⁻¹ q.1) + (F r.2 ∘ₗ adjointDualCoeff U⁻¹ q.2) φ).sum).sum).sum := by + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.map_congr rfl (fun r hr => by + rw [Function.comp_apply, + bracketFam_adjointDualCoeff U⁻¹ p.1 (A r.1 ρ) (F r.2) φ]), + Multiset.sum_map_sum_map] + have hM := hMa.trans ((Multiset.sum_antidiagonal_exchange s fun a b c d => + bracketFam (A b ρ ∘ₗ adjointDualCoeff U⁻¹ a) + (F d ∘ₗ adjointDualCoeff U⁻¹ c) φ).trans hMc.symm) + have hCg : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + ((p.2.antidiagonal.map fun r => F r.2 ∘ₗ adjointDualCoeff U⁻¹ r.1).sum) + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ ρ)))) = + (p.2.antidiagonal.map fun r => + F r.2 (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 (maurerCartanForm U⁻¹ ρ)))))).sum := by + intro p + rw [Multiset.sum_linearMap_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply, LinearMap.coe_comp] + rw [bracketFamConv, Multiset.sum_linearMap_apply, Multiset.map_map, map_multiset_sum, + Multiset.map_map, + Multiset.map_congr rfl (fun p hp => by + rw [Function.comp_apply, Function.comp_apply, + hA.repGauge_bracketFam U (hAlaw p.1) (hFlaw p.2) φ, hCg p, map_zero, + LinearMap.comp_zero, map_zero, sub_zero, lie_zero, map_zero, + Complex.ofReal_zero, map_zero, add_zero]), + Multiset.sum_map_add, hM] + +set_option maxHeartbeats 2000000 in +/-- **Adjoint gauge tensors are closed under the covariant derivative**: if `F` + transforms in the adjoint, so does `∇_ρ F = [∂_ρ F] + ⁅A_ρ, F⁆`. The single + inhomogeneous convolution of `[∂_{ρ ::ₘ s} F]` + (`TransformsInAdjoint.repGauge_cons`) cancels the single `ad` cross-term + convolution of `⁅A_ρ, F⁆` (`TransformsInAdjoint.repGauge_bracketFamConv`) + through the coassociativity of the antidiagonal; no structural equation is needed. + Together with `transformsInAdjoint_fieldStrength` this makes every iterated + covariant derivative of the field strength an adjoint gauge tensor, by recursion. -/ +theorem TransformsInAdjoint.covDerivAdjoint + (hA : IsGaugeField repLorentz repGauge A) + {F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + (hF : TransformsInAdjoint repGauge F) (ρ : Fin 1 ⊕ Fin 3) : + TransformsInAdjoint repGauge (IsGaugeField.covDerivAdjoint A F ρ) := by + intro U φ s + have hL : repGauge U (IsGaugeField.covDerivAdjoint A F ρ s φ) = + repGauge U (F (ρ ::ₘ s) φ) + repGauge U (bracketFamConv A ρ F s φ) := by + rw [covDerivAdjoint_apply, map_add] + have hR : (s.antidiagonal.map fun p => + IsGaugeField.covDerivAdjoint A F ρ p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum = + (s.antidiagonal.map fun p => + F (ρ ::ₘ p.2) (adjointDualCoeff U⁻¹ p.1 φ)).sum + + (s.antidiagonal.map fun p => + bracketFamConv A ρ F p.2 (adjointDualCoeff U⁻¹ p.1 φ)).sum := by + rw [← Multiset.sum_map_add] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [covDerivAdjoint_apply] + have hcancel : (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + F p.2 (adjointDualCoeff U⁻¹ q.2 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum = + (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun r => + F r.2 (adjointDualCoeff U⁻¹ r.1 + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U⁻¹ ρ)))))).sum).sum := + Multiset.sum_antidiagonal_assoc s (fun a b c => + F c (adjointDualCoeff U⁻¹ b + (φ ∘ₗ LieAlgebra.ad ℝ GaugeAlgebra (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv a (maurerCartanForm U⁻¹ ρ)))))) + rw [hL, hF.repGauge_cons U ρ s φ, hF.repGauge_bracketFamConv hA U s ρ φ, + hR, hcancel] + abel + +end IsGaugeField + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/FieldStrength/Basic.lean b/Physlib/Particles/StandardModel/GaugeBosons/FieldStrength/Basic.lean new file mode 100644 index 000000000..f306df66e --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/FieldStrength/Basic.lean @@ -0,0 +1,27 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.TransformsInAdjoint +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.FieldStrength +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Truncation +public import Mathlib.LinearAlgebra.Basis.Defs +public import Mathlib.LinearAlgebra.Dimension.Free +/-! + +# Algebra valued field strength + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Basic.lean new file mode 100644 index 000000000..070d660be --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Basic.lean @@ -0,0 +1,257 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Relativity.DerivAlgebra +public import Physlib.Mathematics.SymmetricAlgebra +public import Mathlib.LinearAlgebra.Dual.Lemmas +/-! +# The jet algebra of the Standard Model gauge bosons + +## i. Overview + +The gauge bosons of the Standard Model are jointly one bosonic field valued in +`Lorentz.CoVector ⊗[ℝ] GaugeAlgebra`: a spacetime covector with values in the gauge +algebra. Its *jet algebra* — the algebra in which the gauge-boson part of a Lagrangian +lives — is the free commutative algebra on the component functions `∂_s A_μ^φ` and is +built here in the same way as the `BBoson` jet algebra, but non-abelian and **without a +basis of the gauge algebra**: the adjoint index is carried by an abstract covector +`φ : Module.Dual ℝ GaugeAlgebra` throughout, following the dual-family formulation of +`Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued`. + +Following the split promised for this directory, the structure is: +1. this file — the target space, the jet component space, and the jet algebra with its + generators; +2. `LorentzAction` — the action of the Lorentz group; +3. `GaugeAction` — the action of the jet gauge group; +4. `JetDeriv` — the formal total derivative; +5. `MassDim` — the mass-dimension grading. + +## ii. Key results + +- `GaugeBoson` : the target space of the gauge-boson field. +- `GaugeBoson.repLorentzGroup` : the Lorentz action on the target space. +- `GaugeBoson.repGaugeGroupI` : the global (adjoint) gauge action on the target space. +- `GaugeBoson.JetComponentSpace` : the span of the component functions `∂_s A_μ^φ`. +- `GaugeJetAlgebra` : the jet algebra of the gauge bosons. +- `GaugeJetAlgebra.ofComponent`, `GaugeJetAlgebra.ofA` : the generators. + +## iii. Table of contents + +- A. The target space of the gauge-boson field + - A.1. Linear structure + - A.2. The Lorentz action on the target space + - A.3. The global gauge action on the target space +- B. The jet component space + - B.1. The component covectors +- C. The jet algebra + - C.1. The generators + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-! + +## A. The target space of the gauge-boson field + +-/ + +/-- The target vector space of the Standard Model gauge-boson field: a spacetime covector + with values in the gauge algebra. Its components are the fields `A_μ^a`; here the + adjoint index is kept abstract, as the gauge-algebra factor. -/ +@[ext] +structure GaugeBoson where + /-- The underlying covector-valued gauge algebra element. -/ + val : Lorentz.CoVector ⊗[ℝ] GaugeAlgebra + +namespace GaugeBoson + +/-! + +### A.1. Linear structure + +-/ + +/-- Identifies a gauge boson with its underlying tensor-product value. -/ +def valEquiv : GaugeBoson ≃ Lorentz.CoVector ⊗[ℝ] GaugeAlgebra where + toFun := val + invFun := fun m => ⟨m⟩ + +noncomputable instance : AddCommGroup GaugeBoson := Equiv.addCommGroup valEquiv + +noncomputable instance : Module ℝ GaugeBoson := Equiv.module ℝ valEquiv + +/-- The linear identification with the underlying tensor product. -/ +def valLinEquiv : GaugeBoson ≃ₗ[ℝ] Lorentz.CoVector ⊗[ℝ] GaugeAlgebra where + toFun := val + invFun := fun m => ⟨m⟩ + map_add' := by intros; rfl + map_smul' := by intros; rfl + +@[simp] +lemma valLinEquiv_apply (v : GaugeBoson) : valLinEquiv v = v.val := rfl + +lemma valLinEquiv_symm_apply (m : Lorentz.CoVector ⊗[ℝ] GaugeAlgebra) : + valLinEquiv.symm m = ⟨m⟩ := rfl + +@[simp] +lemma val_add (v₁ v₂ : GaugeBoson) : (v₁ + v₂).val = v₁.val + v₂.val := rfl + +@[simp] +lemma val_smul (r : ℝ) (v : GaugeBoson) : (r • v).val = r • v.val := rfl + +instance : Module.Finite ℝ GaugeBoson := + Module.Finite.equiv valLinEquiv.symm + +/-! + +### A.2. The Lorentz action on the target space + +-/ + +open Matrix MatrixGroups + +/-- The Lorentz action on the gauge-boson target space: the covector action on the + spacetime index, and the trivial action on the gauge-algebra factor. -/ +noncomputable def repLorentzGroup : Representation ℝ SL(2,ℂ) GaugeBoson where + toFun Λ := valLinEquiv.symm.toLinearMap ∘ₗ + TensorProduct.map (Lorentz.CoVector.sl2Rep Λ) LinearMap.id ∘ₗ + valLinEquiv.toLinearMap + map_one' := by + refine LinearMap.ext fun v => ?_ + simp [Module.End.one_eq_id, TensorProduct.map_id] + map_mul' Λ₁ Λ₂ := by + refine LinearMap.ext fun v => ?_ + simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply, + Module.End.mul_apply, LinearEquiv.apply_symm_apply, map_mul] + congr 1 + rw [← LinearMap.comp_apply, ← TensorProduct.map_comp, LinearMap.id_comp] + rfl + +/-! + +### A.3. The global gauge action on the target space + +-/ + +/-- The global gauge action on the gauge-boson target space: the adjoint action on the + gauge-algebra factor, and the trivial action on the spacetime index. -/ +noncomputable def repGaugeGroupI : Representation ℝ GaugeGroupI GaugeBoson where + toFun g := valLinEquiv.symm.toLinearMap ∘ₗ + TensorProduct.map LinearMap.id (GaugeAlgebra.adjoint g) ∘ₗ + valLinEquiv.toLinearMap + map_one' := by + refine LinearMap.ext fun v => ?_ + simp [Module.End.one_eq_id, TensorProduct.map_id] + map_mul' g₁ g₂ := by + refine LinearMap.ext fun v => ?_ + simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply, + Module.End.mul_apply, LinearEquiv.apply_symm_apply, map_mul] + congr 1 + rw [← LinearMap.comp_apply, ← TensorProduct.map_comp, LinearMap.id_comp] + rfl + +/-! + +## B. The jet component space + +-/ + +/-- The jet component space of the gauge-boson field: the span of the component functions + `∂_s A_μ^φ`. The `DerivAlgebraReal` factor carries the derivative label `s`, and the + dual factor the spacetime and adjoint indices — the latter as an abstract covector on + the gauge algebra, with no basis chosen. Unlike a matter field, the gauge boson is real, + so there is no conjugate half. -/ +abbrev JetComponentSpace : Type := + DerivAlgebraReal ⊗[ℝ] Module.Dual ℝ GaugeBoson + +/-! + +### B.1. The component covectors + +-/ + +/-- The covector on the gauge-boson target space pairing the spacetime index against a + covector `ω` and the adjoint index against `φ`. -/ +noncomputable def componentDual : + Module.Dual ℝ Lorentz.CoVector →ₗ[ℝ] + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] Module.Dual ℝ GaugeBoson where + toFun ω := (Module.Dual.transpose (M := GaugeBoson) valLinEquiv.toLinearMap).comp + ((TensorProduct.dualDistrib ℝ Lorentz.CoVector GaugeAlgebra).comp + (TensorProduct.mk ℝ (Module.Dual ℝ Lorentz.CoVector) (Module.Dual ℝ GaugeAlgebra) ω)) + map_add' ω₁ ω₂ := by + refine LinearMap.ext fun φ => ?_ + simp [TensorProduct.add_tmul] + map_smul' r ω := by + refine LinearMap.ext fun φ => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, TensorProduct.mk_apply, + RingHom.id_apply, LinearMap.smul_apply] + rw [← TensorProduct.smul_tmul', map_smul, map_smul] + +@[simp] +lemma componentDual_apply_val_tmul (ω : Module.Dual ℝ Lorentz.CoVector) + (φ : Module.Dual ℝ GaugeAlgebra) (v : Lorentz.CoVector) (a : GaugeAlgebra) : + componentDual ω φ ⟨v ⊗ₜ[ℝ] a⟩ = ω v * φ a := by + simp [componentDual, Module.Dual.transpose_apply, valLinEquiv_symm_apply] + +end GaugeBoson + +/-! + +## C. The jet algebra + +-/ + +/-- **The jet algebra of the Standard Model gauge bosons**: the free commutative algebra + on the component functions `∂_s A_μ^φ` of the gauge-boson field, realized as the + symmetric algebra on the jet component space. The commutativity of the product is the + Bose statistics of the gauge fields. -/ +abbrev GaugeJetAlgebra : Type := SymmetricAlgebra ℝ GaugeBoson.JetComponentSpace + +namespace GaugeJetAlgebra + +/-! + +### C.1. The generators + +-/ + +/-- The undifferentiated component function `A^φ` of the gauge-boson field along a + covector `φ` on the target space. -/ +noncomputable def ofComponent : Module.Dual ℝ GaugeBoson →ₗ[ℝ] GaugeJetAlgebra := + (SymmetricAlgebra.ι ℝ _).comp + (TensorProduct.mk ℝ DerivAlgebraReal (Module.Dual ℝ GaugeBoson) 1) + +lemma ofComponent_apply (φ : Module.Dual ℝ GaugeBoson) : + ofComponent φ = SymmetricAlgebra.ι ℝ _ ((1 : DerivAlgebraReal) ⊗ₜ[ℝ] φ) := rfl + +/-- **The component function `A_μ^φ` of the gauge-boson field**: the spacetime index `μ` + paired against the Lorentz coordinate basis, the adjoint index against the abstract + covector `φ` on the gauge algebra. These are the generators the ambient theory sees; + no basis of the gauge algebra is involved. -/ +noncomputable def ofA (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] GaugeJetAlgebra := + ofComponent.comp (GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ)) + +lemma ofA_apply (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + ofA μ φ = ofComponent (GaugeBoson.componentDual + (Lorentz.CoVector.basis.dualBasis μ) φ) := rfl + +/-- The jet algebra is generated by the component functions. -/ +@[simp] +lemma adjoin_ι_eq_top : + Algebra.adjoin ℝ (Set.range (SymmetricAlgebra.ι ℝ GaugeBoson.JetComponentSpace)) = ⊤ := + SymmetricAlgebra.adjoin_range_ι + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/GaugeAction.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/GaugeAction.lean new file mode 100644 index 000000000..3bb1418f6 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/GaugeAction.lean @@ -0,0 +1,1002 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Basic +/-! +# The gauge action on the gauge-boson jet algebra + +## i. Overview + +A jet of gauge transformations `U` acts on the gauge field by +`A_μ ↦ Ad_U A_μ + mc(U)_μ`, so on a component function `∂_s A_μ^φ` it acts affinely: the +linear part is the all-orders Leibniz convolution of the Taylor coefficients of `Ad(U⁻¹)` +against lower component functions, and the constant part is the Taylor coefficient of the +Maurer–Cartan form of `U⁻¹`. The action extends to the whole jet algebra as the +substitution homomorphism determined by this affine action on the generators. + +The heart of the file is the *Taylor–Leibniz theorem* for the adjoint action +(`JetGaugeAlgebra.eval_iteratedDeriv_adjointMap`): the base-point Taylor coefficients of +`Ad_U Y` are the convolution of the coefficients of `Ad_U` — the `adjointCoeff` of the +covariance machinery — with those of `Y`. Multiplicativity of the transport and the +cocycle identity for the Maurer–Cartan shift are both corollaries. + +## ii. Key results + +- `JetGaugeAlgebra.eval_iteratedDeriv_adjointMap` : the Taylor–Leibniz theorem for the + adjoint action on jets. +- `IsGaugeField.adjointCoeff_mul` : the Taylor coefficients of `Ad` are multiplicative up + to convolution. +- `GaugeJetAlgebra.transport` : the linear part of the gauge action on the component + space. +- `GaugeJetAlgebra.mcShift` : the Maurer–Cartan shift. +- `GaugeJetAlgebra.repJetGaugeGroupI` : the action of the jet gauge group on the jet + algebra. +- `GaugeJetAlgebra.repJetGaugeGroupI_iteratedJetDeriv_ofA` : the transformation law of + the derivative generators, in the form used by `IsGaugeField`. + +## iii. Table of contents + +- A. Taylor–Leibniz for jets + - A.1. The scalar Leibniz rule for iterated derivatives + - A.2. The matrix Leibniz rule at the base point +- B. The Taylor–Leibniz theorem for the adjoint action + - B.1. Collapsing convolutions against constants + - B.2. The theorem + - B.3. Multiplicativity of the adjoint Taylor coefficients +- C. The transport on the component space +- D. The Maurer–Cartan shift +- E. The action of the jet gauge group + - E.1. The transformation law of the generators + +-/ + +@[expose] public section + +set_option maxHeartbeats 1000000 + +namespace StandardModel + +open TensorProduct MvPowerSeries + +/-! + +## A. Taylor–Leibniz for jets + +-/ + +/-! + +### A.1. The scalar Leibniz rule for iterated derivatives + +-/ + +namespace JetRing + +/-- The iterated formal derivative is additive. -/ +lemma foldl_pderiv_add (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : JetRing) : + s.foldl (fun h ρ => pderiv ℂ ρ h) (f + g) + = s.foldl (fun h ρ => pderiv ℂ ρ h) f + s.foldl (fun h ρ => pderiv ℂ ρ h) g := by + induction s using Multiset.induction_on generalizing f g with + | empty => rfl + | cons μ t ih => rw [Multiset.foldl_cons, Multiset.foldl_cons, Multiset.foldl_cons, + map_add, ih] + +@[simp] +lemma foldl_pderiv_zero (s : Multiset (Fin 1 ⊕ Fin 3)) : + s.foldl (fun h ρ => pderiv ℂ ρ h) (0 : JetRing) = 0 := by + induction s using Multiset.induction_on with + | empty => rfl + | cons μ t ih => rw [Multiset.foldl_cons, map_zero, ih] + +/-- The iterated formal derivative of a finite sum. -/ +lemma foldl_pderiv_sum {κ : Type*} (s : Multiset (Fin 1 ⊕ Fin 3)) (t : Finset κ) + (f : κ → JetRing) : + s.foldl (fun h ρ => pderiv ℂ ρ h) (∑ k ∈ t, f k) + = ∑ k ∈ t, s.foldl (fun h ρ => pderiv ℂ ρ h) (f k) := by + classical + induction t using Finset.induction_on with + | empty => simp + | insert a t ha ih => rw [Finset.sum_insert ha, foldl_pderiv_add, ih, + Finset.sum_insert ha] + +/-- **The all-orders Leibniz rule for the iterated formal derivative** on the jet ring: + the derivative of a product distributes over the antidiagonal of the multiset of + directions. -/ +lemma foldl_pderiv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : JetRing) : + s.foldl (fun h ρ => pderiv ℂ ρ h) (f * g) + = (s.antidiagonal.map fun p => + p.1.foldl (fun h ρ => pderiv ℂ ρ h) f * + p.2.foldl (fun h ρ => pderiv ℂ ρ h) g).sum := by + induction s using Multiset.induction_on generalizing f g with + | empty => simp [Multiset.antidiagonal_zero] + | cons μ t ih => + rw [Multiset.foldl_cons, + show pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g from by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g], + foldl_pderiv_add, ih, ih, + Multiset.map_congr rfl (fun p hp => by + rw [show p.1.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) + = (μ ::ₘ p.1).foldl (fun h ρ => pderiv ℂ ρ h) f from + (Multiset.foldl_cons _ _ _ _).symm]), + show (t.antidiagonal.map fun p => + p.1.foldl (fun h ρ => pderiv ℂ ρ h) f * + p.2.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ g)).sum + = (t.antidiagonal.map fun p => + p.1.foldl (fun h ρ => pderiv ℂ ρ h) f * + (μ ::ₘ p.2).foldl (fun h ρ => pderiv ℂ ρ h) g).sum from + congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [show (μ ::ₘ p.2).foldl (fun h ρ => pderiv ℂ ρ h) g + = p.2.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ g) from + Multiset.foldl_cons _ _ _ _])] + simp only [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, + Multiset.map_map, Function.comp_apply, Prod.map_fst, Prod.map_snd, id_eq] + exact add_comm _ _ + +/-- The base-point Taylor coefficient of a product: the convolution of the base-point + Taylor coefficients. -/ +lemma constantCoeff_foldl_pderiv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (f g : JetRing) : + constantCoeff (s.foldl (fun h ρ => pderiv ℂ ρ h) (f * g)) + = (s.antidiagonal.map fun p => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f) * + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) g)).sum := by + rw [foldl_pderiv_mul, map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => map_mul _ _ _) + +/-- The iterated derivative of a constant jet vanishes for a nonempty multiset of + directions. -/ +lemma foldl_pderiv_C_of_ne_zero {s : Multiset (Fin 1 ⊕ Fin 3)} (hs : s ≠ 0) (c : ℂ) : + s.foldl (fun h ρ => pderiv ℂ ρ h) (C c : JetRing) = 0 := by + obtain ⟨μ, hμ⟩ := Multiset.exists_mem_of_ne_zero hs + obtain ⟨t, rfl⟩ := Multiset.exists_cons_of_mem hμ + rw [Multiset.foldl_cons, pderiv_C, foldl_pderiv_zero] + +end JetRing + +/-! + +### A.2. The matrix Leibniz rule at the base point + +-/ + +/-- The exchange of a finite sum with a multiset sum. -/ +lemma _root_.Multiset.sum_map_finsetSum {α β M : Type*} [AddCommMonoid M] + (m : Multiset α) (t : Finset β) (f : β → α → M) : + (m.map fun a => ∑ b ∈ t, f b a).sum = ∑ b ∈ t, (m.map (f b)).sum := by + induction m using Multiset.induction_on with + | empty => simp + | cons a s ih => + rw [Multiset.map_cons, Multiset.sum_cons, ih, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun b _ => by rw [Multiset.map_cons, Multiset.sum_cons] + +/-- The entry of a multiset sum of matrices is the multiset sum of the entries. -/ +lemma matrix_multiset_sum_apply {κ α : Type*} [AddCommMonoid α] + (m : Multiset (Matrix κ κ α)) (i j : κ) : + m.sum i j = (m.map fun A => A i j).sum := by + induction m using Multiset.induction_on with + | empty => rfl + | cons A t ih => + rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, ← ih, Matrix.add_apply] + +/-- **The matrix Leibniz rule at the base point**: the base-point Taylor coefficients of + a product of matrices of jets are the convolution of the base-point coefficients of the + factors. -/ +lemma matrix_constantCoeff_foldl_pderiv_mul {κ : Type} [Fintype κ] [DecidableEq κ] + (s : Multiset (Fin 1 ⊕ Fin 3)) (M N : Matrix κ κ JetRing) : + ((M * N).map fun f => constantCoeff (s.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (s.antidiagonal.map fun p => + (M.map fun f => constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (N.map fun f => constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + ext i j + rw [Matrix.map_apply, Matrix.mul_apply, JetRing.foldl_pderiv_sum, map_sum] + simp only [JetRing.constantCoeff_foldl_pderiv_mul] + rw [← Multiset.sum_map_finsetSum, matrix_multiset_sum_apply, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, Matrix.mul_apply] + exact Finset.sum_congr rfl fun k _ => by rw [Matrix.map_apply, Matrix.map_apply] + +/-! + +## B. The Taylor–Leibniz theorem for the adjoint action + +-/ + +/-! + +### B.1. Collapsing convolutions against constants + +-/ + +/-- A sum over the antidiagonal of a family vanishing off `p.1 = 0` collapses to the + single term at `(0, s)`. -/ +lemma _root_.Multiset.sum_antidiagonal_eq_of_fst_ne_zero {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (F : Multiset ι × Multiset ι → M) + (hF : ∀ p : Multiset ι × Multiset ι, p.1 ≠ 0 → F p = 0) : + (s.antidiagonal.map F).sum = F (0, s) := by + induction s using Multiset.induction_on generalizing F with + | empty => simp [Multiset.antidiagonal_zero] + | cons a t ih => + rw [Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, Multiset.map_map, + Multiset.map_map, + show ((t.antidiagonal.map (F ∘ Prod.map (Multiset.cons a) id)).sum) = 0 from + Multiset.sum_eq_zero fun x hx => by + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + exact hF _ (Multiset.cons_ne_zero), + add_zero, ih (F ∘ Prod.map id (Multiset.cons a)) fun p hp => hF _ hp] + rfl + +/-- A sum over the antidiagonal of a family vanishing off `p.2 = 0` collapses to the + single term at `(s, 0)`. -/ +lemma _root_.Multiset.sum_antidiagonal_eq_of_snd_ne_zero {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (F : Multiset ι × Multiset ι → M) + (hF : ∀ p : Multiset ι × Multiset ι, p.2 ≠ 0 → F p = 0) : + (s.antidiagonal.map F).sum = F (s, 0) := by + rw [show (s.antidiagonal.map F).sum + = (s.antidiagonal.map fun p => (fun a b => F (b, a)) p.2 p.1).sum from rfl, + ← Multiset.sum_antidiagonal_swap s (fun a b => F (b, a))] + exact Multiset.sum_antidiagonal_eq_of_fst_ne_zero s (fun p => F (p.2, p.1)) + fun p hp => hF _ hp + +/-- The exchange of the second and third slot in a nested antidiagonal sum. -/ +lemma _root_.Multiset.sum_antidiagonal_middle_exchange {ι M : Type*} [AddCommMonoid M] + (s : Multiset ι) (h : Multiset ι → Multiset ι → Multiset ι → M) : + (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => h q.1 q.2 p.2).sum).sum + = (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => h q.1 p.2 q.2).sum).sum := by + rw [Multiset.sum_antidiagonal_assoc s h, + Multiset.sum_antidiagonal_assoc s (fun a b c => h a c b)] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + exact Multiset.sum_antidiagonal_swap p.2 (fun a b => h p.1 a b) + +/-- The convolution against a constant middle matrix: only the empty derivative multiset + survives on the constant factor. -/ +lemma matrix_cc_foldl_conj_const {κ : Type} [Fintype κ] [DecidableEq κ] + (p : Multiset (Fin 1 ⊕ Fin 3)) (P Q : Matrix κ κ JetRing) (b : Matrix κ κ ℂ) : + ((P * b.map (C : ℂ → JetRing) * Q).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (p.antidiagonal.map fun r => + (P.map fun f => constantCoeff (r.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * b * + (Q.map fun f => constantCoeff (r.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have hconst : ∀ m : Multiset (Fin 1 ⊕ Fin 3), + ((b.map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then b else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · ext i j + simp [Matrix.map_apply, constantCoeff_C] + · ext i j + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + rw [matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun q hq => by + rw [matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun r hr => by rw [hconst r.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero q.1 + (fun r => (P.map fun f => + constantCoeff (r.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if r.2 = 0 then b else 0)) + (fun r hr => by rw [if_neg hr, Matrix.mul_zero]), + if_pos rfl])] + +/-! + +### B.2. The theorem + +-/ + +namespace GaugeAlgebra + +/-- The `su(3)` component of a multiset sum. -/ +lemma multiset_sum_toSU3Matrix (m : Multiset GaugeAlgebra) : + m.sum.toSU3Matrix = (m.map GaugeAlgebra.toSU3Matrix).sum := by + induction m using Multiset.induction_on with + | empty => rfl + | cons a t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, ← ih, + GaugeAlgebra.add_toSU3Matrix] + +/-- The `su(2)` component of a multiset sum. -/ +lemma multiset_sum_toSU2Matrix (m : Multiset GaugeAlgebra) : + m.sum.toSU2Matrix = (m.map GaugeAlgebra.toSU2Matrix).sum := by + induction m using Multiset.induction_on with + | empty => rfl + | cons a t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, ← ih, + GaugeAlgebra.add_toSU2Matrix] + +/-- The `u(1)` component of a multiset sum. -/ +lemma multiset_sum_toU1Value (m : Multiset GaugeAlgebra) : + m.sum.toU1Value = (m.map GaugeAlgebra.toU1Value).sum := by + induction m using Multiset.induction_on with + | empty => rfl + | cons a t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, ← ih, + GaugeAlgebra.add_toU1Value] + +end GaugeAlgebra + +namespace JetGaugeAlgebra + +/-- The `su(3)` component of the base-point Taylor coefficients. -/ +lemma eval_iteratedDeriv_toSU3Matrix (x : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (eval (iteratedDeriv x a)).toSU3Matrix + = a.toSU3Matrix.map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + ext i j + rw [eval_toSU3Matrix_apply, iteratedDeriv_toSU3Matrix, Matrix.map_apply, Matrix.map_apply] + +/-- The `su(2)` component of the base-point Taylor coefficients. -/ +lemma eval_iteratedDeriv_toSU2Matrix (x : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (eval (iteratedDeriv x a)).toSU2Matrix + = a.toSU2Matrix.map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + ext i j + rw [eval_toSU2Matrix_apply, iteratedDeriv_toSU2Matrix, Matrix.map_apply, Matrix.map_apply] + +/-- The `u(1)` component of the base-point Taylor coefficients. -/ +lemma eval_iteratedDeriv_toU1Value (x : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + (eval (iteratedDeriv x a)).toU1Value + = constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) a.toU1Value) := by + rw [eval_toU1Value_eq, iteratedDeriv_toU1Value] + +/-- The `su(3)` component of the adjoint Taylor coefficient. -/ +lemma _root_.StandardModel.IsGaugeField.adjointCoeff_toSU3Matrix (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (IsGaugeField.adjointCoeff U p b).toSU3Matrix + = ((U.1.1 * b.toSU3Matrix.map (C : ℂ → JetRing) * star U.1.1).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + rw [IsGaugeField.adjointCoeff] + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [eval_iteratedDeriv_toSU3Matrix, adjointMap_toSU3Matrix, ofConstant_toSU3Matrix] + +/-- The `su(2)` component of the adjoint Taylor coefficient. -/ +lemma _root_.StandardModel.IsGaugeField.adjointCoeff_toSU2Matrix (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (IsGaugeField.adjointCoeff U p b).toSU2Matrix + = ((U.2.1.1 * b.toSU2Matrix.map (C : ℂ → JetRing) * star U.2.1.1).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + rw [IsGaugeField.adjointCoeff] + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [eval_iteratedDeriv_toSU2Matrix, adjointMap_toSU2Matrix, ofConstant_toSU2Matrix] + +/-- The `u(1)` component of the adjoint Taylor coefficient. -/ +lemma _root_.StandardModel.IsGaugeField.adjointCoeff_toU1Value (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (b : GaugeAlgebra) : + (IsGaugeField.adjointCoeff U p b).toU1Value + = constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) (C b.toU1Value)) := by + rw [IsGaugeField.adjointCoeff] + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [eval_iteratedDeriv_toU1Value, adjointMap_toU1Value, ofConstant_toU1Value] + +/-- **The Taylor–Leibniz theorem for the adjoint action on jets**: the base-point Taylor + coefficients of `Ad_U Y` are the antidiagonal convolution of the Taylor coefficients of + `Ad_U` — the `IsGaugeField.adjointCoeff` of the covariance machinery — with those of + `Y`. -/ +theorem eval_iteratedDeriv_adjointMap (U : JetGaugeGroupI) + (x : Multiset (Fin 1 ⊕ Fin 3)) (Y : JetGaugeAlgebra) : + eval (iteratedDeriv x (adjointMap U Y)) + = (x.antidiagonal.map fun p => + IsGaugeField.adjointCoeff U p.1 (eval (iteratedDeriv p.2 Y))).sum := by + have hmat : ∀ {κ : Type} [Fintype κ] [DecidableEq κ] + (P Q W : Matrix κ κ JetRing), + ((P * W * Q).map fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (x.antidiagonal.map fun p => + (p.1.antidiagonal.map fun r => + (P.map fun f => constantCoeff (r.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (W.map fun f => constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (Q.map fun f => + constantCoeff (r.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum).sum := by + intro κ _ _ P Q W + rw [matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by + rw [matrix_constantCoeff_foldl_pderiv_mul, ← Multiset.sum_map_mul_right])] + exact Multiset.sum_antidiagonal_middle_exchange x fun a b c => + (P.map fun f => constantCoeff (a.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (W.map fun f => constantCoeff (b.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (Q.map fun f => constantCoeff (c.foldl (fun h ρ => pderiv ℂ ρ h) f)) + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · rw [GaugeAlgebra.multiset_sum_toSU3Matrix, Multiset.map_map, + eval_iteratedDeriv_toSU3Matrix, adjointMap_toSU3Matrix, hmat U.1.1 (star U.1.1) + Y.toSU3Matrix] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, IsGaugeField.adjointCoeff_toSU3Matrix, + matrix_cc_foldl_conj_const, eval_iteratedDeriv_toSU3Matrix] + · rw [GaugeAlgebra.multiset_sum_toSU2Matrix, Multiset.map_map, + eval_iteratedDeriv_toSU2Matrix, adjointMap_toSU2Matrix, hmat U.2.1.1 (star U.2.1.1) + Y.toSU2Matrix] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, IsGaugeField.adjointCoeff_toSU2Matrix, + matrix_cc_foldl_conj_const, eval_iteratedDeriv_toSU2Matrix] + · rw [GaugeAlgebra.multiset_sum_toU1Value, Multiset.map_map, + eval_iteratedDeriv_toU1Value, adjointMap_toU1Value, + Multiset.map_congr rfl (fun p hp => by + rw [Function.comp_apply, IsGaugeField.adjointCoeff_toU1Value]), + Multiset.sum_antidiagonal_eq_of_fst_ne_zero x + (fun p => constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) + (C ((eval (iteratedDeriv p.2 Y)).toU1Value)))) + (fun p hp => by rw [JetRing.foldl_pderiv_C_of_ne_zero hp, map_zero]), + show ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) + (C ((eval (iteratedDeriv x Y)).toU1Value))) + = C ((eval (iteratedDeriv x Y)).toU1Value) from rfl, + constantCoeff_C, eval_iteratedDeriv_toU1Value] + +/-! + +### B.3. Multiplicativity of the adjoint Taylor coefficients + +-/ + +/-- **The adjoint Taylor coefficients are multiplicative up to convolution**: the + coefficient of a product of jets of gauge transformations is the antidiagonal + convolution of the coefficients of the factors. -/ +lemma _root_.StandardModel.IsGaugeField.adjointCoeff_mul (U V : JetGaugeGroupI) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.adjointCoeff (U * V) x + = (x.antidiagonal.map fun p => + IsGaugeField.adjointCoeff U p.1 ∘ₗ IsGaugeField.adjointCoeff V p.2).sum := by + refine LinearMap.ext fun a => ?_ + rw [Multiset.sum_linearMap_apply, Multiset.map_map, + show IsGaugeField.adjointCoeff (U * V) x a + = eval (iteratedDeriv x (adjointMap U (adjointMap V (ofConstant a)))) from by + rw [IsGaugeField.adjointCoeff] + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [show adjointMap (U * V) (ofConstant a) + = adjointMap U (adjointMap V (ofConstant a)) from by + rw [show adjointMap (U * V) = JetGaugeAlgebra.adjoint (U * V) from rfl, map_mul] + rfl], + eval_iteratedDeriv_adjointMap] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [Function.comp_apply, LinearMap.comp_apply] + rfl) + +/-- The iterated derivative of a constant jet vanishes for a nonempty multiset of + directions. -/ +lemma iteratedDeriv_ofConstant_of_ne_zero {p : Multiset (Fin 1 ⊕ Fin 3)} (hp : p ≠ 0) + (a : GaugeAlgebra) : iteratedDeriv p (ofConstant a) = 0 := by + induction p using Multiset.induction_on with + | empty => exact absurd rfl hp + | cons μ t ih => + rw [iteratedDeriv_cons, LinearMap.comp_apply] + rcases eq_or_ne t 0 with rfl | ht + · rw [iteratedDeriv_zero, LinearMap.id_apply, JetGaugeAlgebra.deriv_ofConstant] + · rw [ih ht, map_zero] + +/-- The adjoint Taylor coefficient of the identity: only the base point survives. -/ +lemma _root_.StandardModel.IsGaugeField.adjointCoeff_one (p : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.adjointCoeff (1 : JetGaugeGroupI) p + = if p = 0 then LinearMap.id else 0 := by + refine LinearMap.ext fun a => ?_ + rw [IsGaugeField.adjointCoeff] + simp only [LinearMap.coe_comp, Function.comp_apply, LieHom.coe_toLinearMap] + rw [show adjointMap (1 : JetGaugeGroupI) (ofConstant a) = ofConstant a from by + rw [show adjointMap (1 : JetGaugeGroupI) = JetGaugeAlgebra.adjoint 1 from rfl, map_one] + rfl] + rcases eq_or_ne p 0 with rfl | hp + · rw [iteratedDeriv_zero, LinearMap.id_apply, eval_ofConstant, if_pos rfl, + LinearMap.id_apply] + · rw [iteratedDeriv_ofConstant_of_ne_zero hp, map_zero, if_neg hp, LinearMap.zero_apply] + +end JetGaugeAlgebra + +/-! + +## C. The transport on the component space + +-/ + +namespace GaugeBoson + +/-- The adjoint transport on the gauge-boson target space at `p` derivatives: the adjoint + Taylor coefficient on the gauge-algebra factor, the identity on the spacetime index. -/ +noncomputable def adjointTransport (U : JetGaugeGroupI) (p : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeBoson →ₗ[ℝ] GaugeBoson := + valLinEquiv.symm.toLinearMap ∘ₗ + TensorProduct.map LinearMap.id (IsGaugeField.adjointCoeff U p) ∘ₗ + valLinEquiv.toLinearMap + +lemma adjointTransport_mk_tmul (U : JetGaugeGroupI) (p : Multiset (Fin 1 ⊕ Fin 3)) + (v : Lorentz.CoVector) (a : GaugeAlgebra) : + adjointTransport U p ⟨v ⊗ₜ[ℝ] a⟩ = ⟨v ⊗ₜ[ℝ] IsGaugeField.adjointCoeff U p a⟩ := rfl + +/-- The adjoint transport at the identity: only the base point survives. -/ +lemma adjointTransport_one (p : Multiset (Fin 1 ⊕ Fin 3)) : + adjointTransport 1 p = if p = 0 then LinearMap.id else 0 := by + rw [adjointTransport, IsGaugeField.adjointCoeff_one] + rcases eq_or_ne p 0 with rfl | hp + · rw [if_pos rfl, if_pos rfl, TensorProduct.map_id] + refine LinearMap.ext fun v => ?_ + simp + · rw [if_neg hp, if_neg hp] + refine LinearMap.ext fun v => ?_ + rw [show TensorProduct.map (LinearMap.id (M := Lorentz.CoVector)) + (0 : GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) = 0 from by + refine TensorProduct.ext' fun x a => ?_ + rw [TensorProduct.map_tmul, LinearMap.zero_apply, TensorProduct.tmul_zero] + rfl] + simp + +/-- The adjoint transport of a product: the antidiagonal convolution of transports. -/ +lemma adjointTransport_mul (U V : JetGaugeGroupI) (p : Multiset (Fin 1 ⊕ Fin 3)) : + adjointTransport (U * V) p + = (p.antidiagonal.map fun r => + adjointTransport U r.1 ∘ₗ adjointTransport V r.2).sum := by + refine LinearMap.ext fun v => ?_ + rw [Multiset.sum_linearMap_apply, Multiset.map_map] + obtain ⟨m⟩ := v + induction m using TensorProduct.induction_on with + | zero => + rw [show (⟨0⟩ : GaugeBoson) = 0 from rfl, map_zero] + refine (Multiset.sum_eq_zero fun x hx => ?_).symm + obtain ⟨r, hr, rfl⟩ := Multiset.mem_map.mp hx + simp + | tmul x a => + apply valLinEquiv.injective + rw [adjointTransport_mk_tmul, map_multiset_sum, Multiset.map_map, valLinEquiv_apply, + show ((⟨x ⊗ₜ[ℝ] IsGaugeField.adjointCoeff (U * V) p a⟩ : GaugeBoson)).val + = x ⊗ₜ[ℝ] IsGaugeField.adjointCoeff (U * V) p a from rfl, + IsGaugeField.adjointCoeff_mul, Multiset.sum_linearMap_apply, Multiset.map_map, + Multiset.tmul_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply, LinearMap.comp_apply, adjointTransport_mk_tmul, + valLinEquiv_apply] + | add m₁ m₂ h₁ h₂ => + rw [show (⟨m₁ + m₂⟩ : GaugeBoson) = (⟨m₁⟩ : GaugeBoson) + ⟨m₂⟩ from rfl, map_add, h₁, + h₂, ← Multiset.sum_map_add] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun r hr => ?_) + simp only [Function.comp_apply] + exact (map_add _ _ _).symm + +/-- The dual transport carries a component covector to the component covector of the + transported adjoint index: the spacetime slot is untouched. -/ +lemma dualMap_adjointTransport_componentDual (U : JetGaugeGroupI) + (p : Multiset (Fin 1 ⊕ Fin 3)) (ω : Module.Dual ℝ Lorentz.CoVector) + (φ : Module.Dual ℝ GaugeAlgebra) : + (adjointTransport U p).dualMap (componentDual ω φ) + = componentDual ω (φ ∘ₗ IsGaugeField.adjointCoeff U p) := by + refine LinearMap.ext fun v => ?_ + obtain ⟨m⟩ := v + induction m using TensorProduct.induction_on with + | zero => + rw [show (⟨0⟩ : GaugeBoson) = 0 from rfl, map_zero, map_zero] + | tmul x a => + rw [LinearMap.dualMap_apply, adjointTransport_mk_tmul, + componentDual_apply_val_tmul, componentDual_apply_val_tmul] + rfl + | add m₁ m₂ h₁ h₂ => + rw [show (⟨m₁ + m₂⟩ : GaugeBoson) = (⟨m₁⟩ : GaugeBoson) + ⟨m₂⟩ from rfl, map_add, + map_add, h₁, h₂] + +end GaugeBoson + +namespace GaugeJetAlgebra + +/-- The value of the transport on the derivative symbol at `s`: the all-orders Leibniz + convolution of the dual adjoint transports against lower derivative symbols. -/ +noncomputable def transportFun (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℝ GaugeBoson →ₗ[ℝ] GaugeBoson.JetComponentSpace := + (s.antidiagonal.map fun p => + (TensorProduct.mk ℝ DerivAlgebraReal (Module.Dual ℝ GaugeBoson) + (LagrangianTheory.dualRealJetAlgebraBasis p.2)).comp + ((GaugeBoson.adjointTransport U p.1).dualMap)).sum + +/-- **The linear part of the gauge action on the jet component space**: on a component + function `∂_s A^ψ` it is the all-orders Leibniz convolution of the Taylor coefficients + of the adjoint action of `U` against the lower component functions. -/ +noncomputable def transport (U : JetGaugeGroupI) : + GaugeBoson.JetComponentSpace →ₗ[ℝ] GaugeBoson.JetComponentSpace := + TensorProduct.lift (LagrangianTheory.dualRealJetAlgebraBasis.constr ℝ (transportFun U)) + +lemma transport_basis_tmul (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) + (ψ : Module.Dual ℝ GaugeBoson) : + transport U (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + LagrangianTheory.dualRealJetAlgebraBasis p.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport U p.1).dualMap ψ).sum := by + rw [transport, TensorProduct.lift.tmul, Module.Basis.constr_basis, transportFun, + Multiset.sum_linearMap_apply, Multiset.map_map] + rfl + +/-- Two maps out of the jet component space agree if they agree on the components + `∂_s A^ψ` with `s` a derivative multiset and `ψ` an arbitrary covector. -/ +lemma _root_.StandardModel.GaugeBoson.JetComponentSpace.ext_of_basis + {M : Type*} [AddCommMonoid M] [Module ℝ M] + {F G : GaugeBoson.JetComponentSpace →ₗ[ℝ] M} + (h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ GaugeBoson), + F (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + = G (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ)) : F = G := by + refine LinearMap.ext fun x => ?_ + induction x using TensorProduct.induction_on with + | zero => rw [map_zero, map_zero] + | add a b ha hb => rw [map_add, map_add, ha, hb] + | tmul a ψ => + have ha : a ∈ Submodule.span ℝ + (Set.range LagrangianTheory.dualRealJetAlgebraBasis) := by + rw [LagrangianTheory.dualRealJetAlgebraBasis.span_eq]; trivial + induction ha using Submodule.span_induction with + | mem b hb => obtain ⟨s, rfl⟩ := hb; exact h s ψ + | zero => rw [TensorProduct.zero_tmul, map_zero, map_zero] + | add b c _ _ hb hc => rw [TensorProduct.add_tmul, map_add, map_add, hb, hc] + | smul c b _ hb => rw [← TensorProduct.smul_tmul', map_smul, map_smul, hb] + +/-- The transport of the identity is the identity. -/ +lemma transport_one : transport (1 : JetGaugeGroupI) = LinearMap.id := by + refine GaugeBoson.JetComponentSpace.ext_of_basis fun s ψ => ?_ + rw [transport_basis_tmul, + Multiset.map_congr rfl (fun p hp => by rw [GaugeBoson.adjointTransport_one]), + Multiset.sum_antidiagonal_eq_of_fst_ne_zero s + (fun p => LagrangianTheory.dualRealJetAlgebraBasis p.2 ⊗ₜ[ℝ] + ((if p.1 = 0 then LinearMap.id else 0) : + GaugeBoson →ₗ[ℝ] GaugeBoson).dualMap ψ) + (fun p hp => by + rw [if_neg hp, show ((0 : GaugeBoson →ₗ[ℝ] GaugeBoson)).dualMap ψ = 0 from + LinearMap.ext fun v => by simp, TensorProduct.tmul_zero]), + if_pos rfl, LinearMap.id_apply, + show (LinearMap.id : GaugeBoson →ₗ[ℝ] GaugeBoson).dualMap ψ = ψ from + LinearMap.ext fun v => rfl] + +/-- **The transport is an anti-homomorphism**: the transport of a product is the reverse + composite. Composed with the inverse, it becomes the linear part of the gauge + representation. -/ +lemma transport_mul (U V : JetGaugeGroupI) : + transport (U * V) = transport V ∘ₗ transport U := by + refine GaugeBoson.JetComponentSpace.ext_of_basis fun s ψ => ?_ + have hdual : ∀ (p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3)), + (GaugeBoson.adjointTransport (U * V) p.1).dualMap ψ + = (p.1.antidiagonal.map fun r => + (GaugeBoson.adjointTransport V r.2).dualMap + ((GaugeBoson.adjointTransport U r.1).dualMap ψ)).sum := by + intro p + rw [GaugeBoson.adjointTransport_mul] + refine LinearMap.ext fun v => ?_ + rw [LinearMap.dualMap_apply, Multiset.sum_linearMap_apply, Multiset.map_map, + map_multiset_sum, Multiset.map_map, Multiset.sum_linearMap_apply, Multiset.map_map] + rfl + have hLHS : transport (U * V) (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + (p.1.antidiagonal.map fun q => + LagrangianTheory.dualRealJetAlgebraBasis p.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport V q.2).dualMap + ((GaugeBoson.adjointTransport U q.1).dualMap ψ)).sum).sum := by + rw [transport_basis_tmul] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [hdual p, Multiset.tmul_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun q hq => rfl) + have hRHS : (transport V ∘ₗ transport U) + (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + = (s.antidiagonal.map fun p => + (p.2.antidiagonal.map fun q => + LagrangianTheory.dualRealJetAlgebraBasis q.2 ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport V q.1).dualMap + ((GaugeBoson.adjointTransport U p.1).dualMap ψ)).sum).sum := by + rw [LinearMap.comp_apply, transport_basis_tmul, map_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + exact transport_basis_tmul V p.2 _ + rw [hLHS, hRHS] + exact Multiset.sum_antidiagonal_assoc s fun a b c => + LagrangianTheory.dualRealJetAlgebraBasis c ⊗ₜ[ℝ] + (GaugeBoson.adjointTransport V b).dualMap + ((GaugeBoson.adjointTransport U a).dualMap ψ) + +end GaugeJetAlgebra + +/-! + +## D. The Maurer–Cartan shift + +-/ + +namespace GaugeJetAlgebra + +/-- The Taylor coefficient of the Maurer–Cartan form of `U` at the derivative multiset + `s`, packaged as a gauge boson: the spacetime index runs over the coordinate + directions, the adjoint index over the base-point Taylor coefficients of the + Maurer–Cartan form. -/ +noncomputable def mcBosonCoeff (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeBoson := + ⟨∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s (maurerCartanForm U μ))⟩ + +@[simp] +lemma mcBosonCoeff_one (s : Multiset (Fin 1 ⊕ Fin 3)) : mcBosonCoeff 1 s = 0 := by + rw [show (0 : GaugeBoson) = ⟨0⟩ from rfl, mcBosonCoeff] + congr 1 + refine Finset.sum_eq_zero fun μ _ => ?_ + rw [show maurerCartanForm 1 μ = 0 from congrFun maurerCartanForm_one μ, map_zero, + map_zero, TensorProduct.tmul_zero] + +/-- The Maurer–Cartan Taylor coefficients of a product: the cocycle identity, with the + adjoint transport convoluted in by the Taylor–Leibniz theorem. -/ +lemma mcBosonCoeff_mul (U V : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) : + mcBosonCoeff (U * V) s + = mcBosonCoeff U s + + (s.antidiagonal.map fun p => + GaugeBoson.adjointTransport U p.1 (mcBosonCoeff V p.2)).sum := by + apply GaugeBoson.valLinEquiv.injective + have hE : ∀ (W : JetGaugeGroupI) (t : Multiset (Fin 1 ⊕ Fin 3)), + GaugeBoson.valLinEquiv (mcBosonCoeff W t) + = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv t + (maurerCartanForm W μ)) := fun W t => rfl + have hB : ∀ p q : Multiset (Fin 1 ⊕ Fin 3), + GaugeBoson.valLinEquiv (GaugeBoson.adjointTransport U p (mcBosonCoeff V q)) + = ∑ μ, Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + IsGaugeField.adjointCoeff U p (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv q (maurerCartanForm V μ))) := by + intro p q + rw [show GaugeBoson.valLinEquiv (GaugeBoson.adjointTransport U p (mcBosonCoeff V q)) + = TensorProduct.map LinearMap.id (IsGaugeField.adjointCoeff U p) + (GaugeBoson.valLinEquiv (mcBosonCoeff V q)) from by + rw [GaugeBoson.adjointTransport] + simp only [LinearMap.coe_comp, LinearEquiv.coe_coe, Function.comp_apply, + LinearEquiv.apply_symm_apply], + hE, map_sum] + exact Finset.sum_congr rfl fun μ _ => by + rw [TensorProduct.map_tmul, LinearMap.id_apply] + have hA : GaugeBoson.valLinEquiv (mcBosonCoeff (U * V) s) + = ∑ μ, (Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s (maurerCartanForm U μ)) + + (s.antidiagonal.map fun p => + Lorentz.CoVector.basis μ ⊗ₜ[ℝ] + IsGaugeField.adjointCoeff U p.1 (JetGaugeAlgebra.eval + (JetGaugeAlgebra.iteratedDeriv p.2 (maurerCartanForm V μ)))).sum) := by + rw [hE] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [show maurerCartanForm (U * V) μ + = maurerCartanForm U μ + JetGaugeAlgebra.adjoint U (maurerCartanForm V μ) from + maurerCartanForm_cocycle U V μ, + map_add, map_add, + show JetGaugeAlgebra.adjoint U (maurerCartanForm V μ) + = JetGaugeAlgebra.adjointMap U (maurerCartanForm V μ) from rfl, + JetGaugeAlgebra.eval_iteratedDeriv_adjointMap, TensorProduct.tmul_add, + Multiset.tmul_sum, Multiset.map_map] + exact congrArg (fun z => _ + z) + (congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => rfl)) + rw [hA, Finset.sum_add_distrib, map_add, map_multiset_sum, Multiset.map_map, ← hE, + ← Multiset.sum_map_finsetSum] + congr 1 + +/-- **The Maurer–Cartan shift**: the linear functional on the component space pairing a + component `∂_s A^ψ` with the Taylor coefficient of the Maurer–Cartan form of `U`. It is + the constant part of the affine gauge action. -/ +noncomputable def mcShift (U : JetGaugeGroupI) : GaugeBoson.JetComponentSpace →ₗ[ℝ] ℝ := + TensorProduct.lift (LagrangianTheory.dualRealJetAlgebraBasis.constr ℝ fun s => + Module.Dual.eval ℝ GaugeBoson (mcBosonCoeff U s)) + +lemma mcShift_basis_tmul (U : JetGaugeGroupI) (s : Multiset (Fin 1 ⊕ Fin 3)) + (ψ : Module.Dual ℝ GaugeBoson) : + mcShift U (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + = ψ (mcBosonCoeff U s) := by + rw [mcShift, TensorProduct.lift.tmul, Module.Basis.constr_basis] + rfl + +@[simp] +lemma mcShift_one : mcShift (1 : JetGaugeGroupI) = 0 := by + refine GaugeBoson.JetComponentSpace.ext_of_basis fun s ψ => ?_ + rw [mcShift_basis_tmul, mcBosonCoeff_one, map_zero, LinearMap.zero_apply] + +/-- **The cocycle identity for the Maurer–Cartan shift.** -/ +lemma mcShift_mul (U V : JetGaugeGroupI) : + mcShift (U * V) = mcShift V ∘ₗ transport U + mcShift U := by + refine GaugeBoson.JetComponentSpace.ext_of_basis fun s ψ => ?_ + rw [LinearMap.add_apply, LinearMap.comp_apply, mcShift_basis_tmul, mcBosonCoeff_mul, + map_add, add_comm] + congr 1 + · rw [map_multiset_sum, Multiset.map_map, transport_basis_tmul, map_multiset_sum, + Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, Function.comp_apply, mcShift_basis_tmul] + rfl + · exact (mcShift_basis_tmul U s ψ).symm + +/-! + +## E. The action of the jet gauge group + +-/ + +/-- The affine action of a jet of gauge transformations on the generators of the jet + algebra: the transported component plus the Maurer–Cartan shift, both of `U⁻¹` — the + contragredient convention for an action on component functions. -/ +noncomputable def gaugeGen (U : JetGaugeGroupI) : + GaugeBoson.JetComponentSpace →ₗ[ℝ] GaugeJetAlgebra := + (SymmetricAlgebra.ι ℝ GaugeBoson.JetComponentSpace).comp (transport U⁻¹) + + (Algebra.linearMap ℝ GaugeJetAlgebra).comp (mcShift U⁻¹) + +lemma gaugeGen_apply (U : JetGaugeGroupI) (x : GaugeBoson.JetComponentSpace) : + gaugeGen U x = SymmetricAlgebra.ι ℝ _ (transport U⁻¹ x) + + algebraMap ℝ GaugeJetAlgebra (mcShift U⁻¹ x) := rfl + +/-- **The action of the jet gauge group on the gauge-boson jet algebra**: the substitution + homomorphism determined by the affine action on the generators, `∂_s A^ψ` going to its + transported convolution plus the Maurer–Cartan shift of `U⁻¹`. -/ +noncomputable def repJetGaugeGroupI : Representation ℝ JetGaugeGroupI GaugeJetAlgebra where + toFun U := (SymmetricAlgebra.lift (gaugeGen U)).toLinearMap + map_one' := by + suffices h : SymmetricAlgebra.lift (gaugeGen 1) = AlgHom.id ℝ GaugeJetAlgebra by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + show SymmetricAlgebra.lift (gaugeGen 1) (SymmetricAlgebra.ι ℝ _ x) + = AlgHom.id ℝ GaugeJetAlgebra (SymmetricAlgebra.ι ℝ _ x) + rw [SymmetricAlgebra.lift_ι_apply, gaugeGen_apply, inv_one, transport_one, + mcShift_one, LinearMap.id_apply, LinearMap.zero_apply, map_zero, add_zero] + rfl + map_mul' U V := by + suffices h : SymmetricAlgebra.lift (gaugeGen (U * V)) + = (SymmetricAlgebra.lift (gaugeGen U)).comp (SymmetricAlgebra.lift (gaugeGen V)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + show SymmetricAlgebra.lift (gaugeGen (U * V)) (SymmetricAlgebra.ι ℝ _ x) + = ((SymmetricAlgebra.lift (gaugeGen U)).comp (SymmetricAlgebra.lift (gaugeGen V))) + (SymmetricAlgebra.ι ℝ _ x) + rw [SymmetricAlgebra.lift_ι_apply, gaugeGen_apply, AlgHom.comp_apply, + SymmetricAlgebra.lift_ι_apply, gaugeGen_apply, map_add, + SymmetricAlgebra.lift_ι_apply, gaugeGen_apply, AlgHom.commutes, + mul_inv_rev, transport_mul, mcShift_mul, LinearMap.comp_apply, + LinearMap.add_apply, LinearMap.comp_apply, map_add, add_assoc] + +/-- The action of `U` as an algebra homomorphism: a jet of gauge transformations acts on + a Lagrangian term factor by factor. -/ +noncomputable def repJetGaugeGroupIAlgHom (U : JetGaugeGroupI) : + GaugeJetAlgebra →ₐ[ℝ] GaugeJetAlgebra := + SymmetricAlgebra.lift (gaugeGen U) + +@[simp] +lemma repJetGaugeGroupI_ι (U : JetGaugeGroupI) (x : GaugeBoson.JetComponentSpace) : + repJetGaugeGroupI U (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.ι ℝ _ (transport U⁻¹ x) + + algebraMap ℝ GaugeJetAlgebra (mcShift U⁻¹ x) := by + rw [show repJetGaugeGroupI U (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.lift (gaugeGen U) (SymmetricAlgebra.ι ℝ _ x) from rfl, + SymmetricAlgebra.lift_ι_apply, gaugeGen_apply] + +@[simp] +lemma repJetGaugeGroupI_apply_one (U : JetGaugeGroupI) : + repJetGaugeGroupI U (1 : GaugeJetAlgebra) = 1 := by + rw [show repJetGaugeGroupI U (1 : GaugeJetAlgebra) + = SymmetricAlgebra.lift (gaugeGen U) 1 from rfl, map_one] + +lemma repJetGaugeGroupI_apply_mul (U : JetGaugeGroupI) (x y : GaugeJetAlgebra) : + repJetGaugeGroupI U (x * y) = repJetGaugeGroupI U x * repJetGaugeGroupI U y := by + rw [show repJetGaugeGroupI U (x * y) + = SymmetricAlgebra.lift (gaugeGen U) (x * y) from rfl, map_mul] + rfl + +@[simp] +lemma repJetGaugeGroupI_algebraMap (U : JetGaugeGroupI) (r : ℝ) : + repJetGaugeGroupI U (algebraMap ℝ GaugeJetAlgebra r) + = algebraMap ℝ GaugeJetAlgebra r := by + rw [show repJetGaugeGroupI U (algebraMap ℝ GaugeJetAlgebra r) + = SymmetricAlgebra.lift (gaugeGen U) (algebraMap ℝ GaugeJetAlgebra r) from rfl, + AlgHom.commutes] + +/-! + +### E.1. The transformation law of the generators + +-/ + +/-- The component covector at `μ` picks the `μ`-th Maurer–Cartan Taylor coefficient out + of the shift. -/ +lemma componentDual_dualBasis_mcBosonCoeff (W : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ) φ (mcBosonCoeff W s) + = φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s + (maurerCartanForm W μ))) := by + have hsum : mcBosonCoeff W s + = ∑ ν, (⟨Lorentz.CoVector.basis ν ⊗ₜ[ℝ] + JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s + (maurerCartanForm W ν))⟩ : GaugeBoson) := by + apply GaugeBoson.valLinEquiv.injective + rw [map_sum] + rfl + rw [hsum, map_sum] + rw [Finset.sum_congr rfl fun ν _ => GaugeBoson.componentDual_apply_val_tmul _ _ _ _] + rw [Finset.sum_congr rfl fun ν _ => by + rw [Module.Basis.dualBasis_apply_self, ite_mul, one_mul, zero_mul]] + rw [Finset.sum_ite_eq' Finset.univ μ + (fun ν => φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s + (maurerCartanForm W ν)))), if_pos (Finset.mem_univ μ)] + +/-- **The transformation law of the derivative generators**, in the form used by + `IsGaugeField`: a jet of gauge transformations acts on `∂_s A_μ^φ` by the all-orders + Leibniz convolution of the adjoint Taylor coefficients of `U⁻¹` against lower + generators, plus the Taylor coefficient of the Maurer–Cartan form of `U⁻¹`. -/ +theorem repJetGaugeGroupI_iteratedJetDeriv_ofA (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repJetGaugeGroupI U (iteratedJetDeriv s (ofA μ φ)) + = (s.antidiagonal.map fun p => + iteratedJetDeriv p.2 (ofA μ (adjointDualCoeff U⁻¹ p.1 φ))).sum + + algebraMap ℝ GaugeJetAlgebra + (φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s + (maurerCartanForm U⁻¹ μ)))) := by + rw [iteratedJetDeriv_ofA, repJetGaugeGroupI_ι, transport_basis_tmul, mcShift_basis_tmul, + componentDual_dualBasis_mcBosonCoeff, map_multiset_sum, Multiset.map_map] + congr 1 + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, GaugeBoson.dualMap_adjointTransport_componentDual, + iteratedJetDeriv_ofA] + rfl + +/-! + +### E.2. The complexified action + +-/ + +/-- The action of the jet gauge group on the complexified gauge-boson jet algebra, by + base change. -/ +noncomputable def complexRepJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (ℂ ⊗[ℝ] GaugeJetAlgebra) where + toFun U := LinearMap.baseChange ℂ (repJetGaugeGroupI U) + map_one' := by + rw [map_one, Module.End.one_eq_id, LinearMap.baseChange_id, Module.End.one_eq_id] + map_mul' U V := by + rw [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp, Module.End.mul_eq_comp] + +@[simp] +lemma complexRepJetGaugeGroupI_tmul (U : JetGaugeGroupI) (z : ℂ) (x : GaugeJetAlgebra) : + complexRepJetGaugeGroupI U (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] repJetGaugeGroupI U x := rfl + +lemma complexRepJetGaugeGroupI_apply_mul (U : JetGaugeGroupI) + (x y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + complexRepJetGaugeGroupI U (x * y) + = complexRepJetGaugeGroupI U x * complexRepJetGaugeGroupI U y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => rw [add_mul, map_add, map_add, h₁, h₂, add_mul] + | tmul z₁ a₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => rw [mul_add, map_add, map_add, h₁, h₂, mul_add] + | tmul z₂ a₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, complexRepJetGaugeGroupI_tmul, + complexRepJetGaugeGroupI_tmul, complexRepJetGaugeGroupI_tmul, + repJetGaugeGroupI_apply_mul, Algebra.TensorProduct.tmul_mul_tmul] + +/-- The iterated complexified derivative of a real element is the complexification of the + iterated real derivative. -/ +lemma iteratedD_complexJetDeriv_one_tmul (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : GaugeJetAlgebra) : + Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm s ((1 : ℂ) ⊗ₜ[ℝ] x) + = (1 : ℂ) ⊗ₜ[ℝ] iteratedJetDeriv s x := by + induction s using Multiset.induction_on generalizing x with + | empty => rw [Lorentz.iteratedD_zero, iteratedJetDeriv_zero]; rfl + | cons μ s ih => + rw [Lorentz.iteratedD_cons, LinearMap.comp_apply, ih, complexJetDeriv_tmul, + iteratedJetDeriv_cons, LinearMap.comp_apply] + +/-- A real scalar in the complexified jet algebra is the corresponding complex scalar. -/ +lemma one_tmul_algebraMap (r : ℝ) : + (1 : ℂ) ⊗ₜ[ℝ] (algebraMap ℝ GaugeJetAlgebra r) + = algebraMap ℂ (ℂ ⊗[ℝ] GaugeJetAlgebra) ((r : ℝ) : ℂ) := by + rw [Algebra.algebraMap_eq_smul_one, TensorProduct.tmul_smul, + Algebra.algebraMap_eq_smul_one, + show ((r : ℝ) • ((1 : ℂ) ⊗ₜ[ℝ] (1 : GaugeJetAlgebra))) + = (((r : ℝ) : ℂ)) • ((1 : ℂ) ⊗ₜ[ℝ] (1 : GaugeJetAlgebra)) from + (algebraMap_smul ℂ r _).symm, Algebra.TensorProduct.one_def] + +/-- **The transformation law of the derivative generators on the complexification**: the + form consumed by the `IsGaugeField` structure of the ambient Lagrangian theory. -/ +theorem complexRepJetGaugeGroupI_iteratedD_one_tmul_ofA (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + complexRepJetGaugeGroupI U (Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm s + ((1 : ℂ) ⊗ₜ[ℝ] ofA μ φ)) + = (s.antidiagonal.map fun p => + Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm p.2 + ((1 : ℂ) ⊗ₜ[ℝ] ofA μ (adjointDualCoeff U⁻¹ p.1 φ))).sum + + algebraMap ℂ (ℂ ⊗[ℝ] GaugeJetAlgebra) + (((φ (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv s + (maurerCartanForm U⁻¹ μ))) : ℝ)) : ℂ) := by + rw [iteratedD_complexJetDeriv_one_tmul, complexRepJetGaugeGroupI_tmul, + repJetGaugeGroupI_iteratedJetDeriv_ofA, TensorProduct.tmul_add, Multiset.tmul_sum, + Multiset.map_map, one_tmul_algebraMap] + congr 1 + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [Function.comp_apply, iteratedD_complexJetDeriv_one_tmul]) + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Invariants.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Invariants.lean new file mode 100644 index 000000000..78b160e39 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/Invariants.lean @@ -0,0 +1,148 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Symmeterized +/-! +# Gauge invariants of the gauge-boson jet algebra + +## i. Overview + +The gauge-boson jet algebra, complexified, together with its Lorentz action, jet gauge +action and gauge-field derivative symbols, is a *gauge field* in the sense of +the abstract covariance machinery of +`Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued`: the structure `IsGaugeField` +holds. This file establishes that instance and instantiates the abstract classification +of invariants: + +**a gauge-invariant element of the subalgebra generated by the gauge-field symbols +`∂_s A_μ^φ` — together with any set `S` of elements fixed by the pure jets — is a +polynomial in the covariant derivatives of the field strength and the elements of `S`.** + +This is the covariance reduction for the gauge sector: after it, only the field +strengths, their covariant derivatives, and the matter content `S` remain. + +## ii. Key results + +- `GaugeJetAlgebra.gaugeField` : the gauge-field derivative symbols, as a family over the + derivative multiset and the dual of the gauge algebra. +- `GaugeJetAlgebra.isGaugeField` : the complexified gauge-boson jet algebra is a gauge + field. +- `GaugeJetAlgebra.invariant_mem_adjoin_fieldStrength` : the classification of gauge + invariants. + +## iii. Table of contents + +- A. The gauge-field structure + - A.1. The gauge-field derivative symbols + - A.2. The `IsGaugeField` instance +- B. The classification of gauge invariants + +-/ + +@[expose] public section + +set_option maxHeartbeats 1000000 + +namespace StandardModel + +namespace GaugeJetAlgebra + +open TensorProduct Matrix MatrixGroups + +/-! + +## A. The gauge-field structure + +-/ + +/-! + +### A.1. The gauge-field derivative symbols + +-/ + +/-- The gauge-field derivative symbols of the complexified gauge-boson jet algebra, as a + family over the derivative multiset, the spacetime index and the dual of the gauge + algebra — the form consumed by the abstract covariance machinery. -/ +noncomputable def gaugeField (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] ℂ ⊗[ℝ] GaugeJetAlgebra := + (Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm s).restrictScalars ℝ ∘ₗ + (TensorProduct.mk ℝ ℂ GaugeJetAlgebra 1).comp (ofA μ) + +@[simp] +lemma gaugeField_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + gaugeField s μ φ = Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm s + ((1 : ℂ) ⊗ₜ[ℝ] ofA μ φ) := rfl + +/-! + +### A.2. The `IsGaugeField` instance + +-/ + +/-- **The complexified gauge-boson jet algebra is a gauge field**: its derivative symbols + are those of a Lorentz covector, transform under the jet gauge group by the all-orders + Leibniz convolution of the adjoint Taylor coefficients plus the Maurer–Cartan shift, and + the gauge action is multiplicative. -/ +theorem isGaugeField : + IsGaugeField complexRepLorentzGroup complexRepJetGaugeGroupI gaugeField where + lorentz_apply Λ n l μ φ := by + calc complexRepLorentzGroup Λ (gaugeField (List.ofFn l) μ φ) + = ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((Lorentz.SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + Lorentz.iteratedD complexJetDeriv complexJetDeriv_comm (List.ofFn p) + (complexRepLorentzGroup Λ ((1 : ℂ) ⊗ₜ[ℝ] ofA μ φ)) := + Lorentz.IsLorentzDeriv.rep_iteratedD_ofFn complexJetDeriv_comm Λ l + ((1 : ℂ) ⊗ₜ[ℝ] ofA μ φ) + _ = _ := by + refine Finset.sum_congr rfl fun p _ => ?_ + rw [complexRepLorentzGroup_one_tmul_ofA, map_sum] + refine congrArg (HSMul.hSMul _) (Finset.sum_congr rfl fun a _ => ?_) + rw [map_smul] + rfl + gauge_apply_deriv U s μ φ := complexRepJetGaugeGroupI_iteratedD_one_tmul_ofA U s μ φ + gauge_mul U b₁ b₂ := complexRepJetGaugeGroupI_apply_mul U b₁ b₂ + +/-! + +## B. The classification of gauge invariants + +-/ + +/-- **The classification of gauge invariants of the gauge-boson jet algebra**: a + gauge-invariant element of the subalgebra generated by the gauge-field symbols + `∂_s A_μ^φ` and a set `S` of elements fixed by the pure jets — for instance, the + covariant towers of matter fields — is a polynomial in the covariant derivatives of the + field strength and the elements of `S`. + + This is the covariance reduction of the gauge sector: invariance eliminates the bare + gauge-field symbols in favour of the field strength and its covariant derivatives. -/ +theorem invariant_mem_adjoin_fieldStrength + (S : Set (ℂ ⊗[ℝ] GaugeJetAlgebra)) + (hS : ∀ y ∈ S, ∀ U : JetGaugeGroupI.truncationKer 0, + complexRepJetGaugeGroupI U.1 y = y) + {x : ℂ ⊗[ℝ] GaugeJetAlgebra} + (hx : x ∈ Algebra.adjoin ℂ ({b : ℂ ⊗[ℝ] GaugeJetAlgebra | + ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = gaugeField p μ φ} ∪ S)) + (hinv : ∀ U : JetGaugeGroupI, complexRepJetGaugeGroupI U x = x) : + x ∈ Algebra.adjoin ℂ ({b : ℂ ⊗[ℝ] GaugeJetAlgebra | + ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = IsGaugeField.iteratedCovDerivAdjoint gaugeField l + (IsGaugeField.fieldStrength gaugeField ν lam) 0 φ} ∪ S) := + IsGaugeField.invariant_mem_adjoin_fieldStrength isGaugeField + (fun _ _ _ _ _ _ => Commute.all _ _) + S (fun _ _ _ _ _ => Commute.all _ _) hS hx hinv + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/JetDeriv.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/JetDeriv.lean new file mode 100644 index 000000000..54349c19d --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/JetDeriv.lean @@ -0,0 +1,370 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Basic +public import Physlib.Particles.LagrangianTheory.Basic +/-! +# The formal total derivative on the gauge-boson jet algebra + +## i. Overview + +The formal total spacetime derivative extends from the component functions of the gauge +bosons to their whole jet algebra as a derivation: it is +`SymmetricAlgebra.derivationOfLinear` applied to the shift `∂_s A_μ^φ ↦ ∂_{s + {ν}} A_μ^φ` +on the jet component space, which is right multiplication by the derivative symbol `∂_ν` +on the `DerivAlgebraReal` factor. + +The four directional derivatives commute and iterate along a multiset of directions. The +jet algebra is generated by the gauge fields and their iterated derivatives, and the +derivative extends to the complexification `ℂ ⊗[ℝ] GaugeJetAlgebra` by base change, where +the ambient Lagrangian theory uses it. + +## ii. Key results + +- `GaugeBoson.JetComponentSpace.jetDeriv` : the derivative shift on the component space. +- `GaugeJetAlgebra.jetDeriv` : the formal total derivative, a derivation. +- `GaugeJetAlgebra.iteratedJetDeriv` : the iterated derivative along a multiset. +- `GaugeJetAlgebra.iteratedJetDeriv_ofA` : `∂_s A_μ^φ` as a generator. +- `GaugeJetAlgebra.adjoin_iteratedJetDeriv_eq_top` : the algebra is generated by the + gauge fields and their derivatives. +- `GaugeJetAlgebra.complexJetDeriv` : the derivative on the complexification. + +## iii. Table of contents + +- A. The derivative on the jet component space +- B. The total derivative on the jet algebra +- C. The iterated total derivative +- D. Generation by the gauge fields and their derivatives +- E. The derivative on the complexification + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-! + +## A. The derivative on the jet component space + +-/ + +namespace GaugeBoson + +/-- The derivative of components in the jet component space, in the direction `ν`: the + shift `∂_s A_μ^φ ↦ ∂_{s + {ν}} A_μ^φ` of the derivative label, i.e. right multiplication + by the degree-one symbol `∂_ν` on the `DerivAlgebraReal` factor. -/ +noncomputable def JetComponentSpace.jetDeriv (ν : Fin 1 ⊕ Fin 3) : + JetComponentSpace →ₗ[ℝ] JetComponentSpace := + TensorProduct.map + (LinearMap.mulRight ℝ + (LagrangianTheory.dualRealJetAlgebraBasis ({ν} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id + +@[simp] +lemma JetComponentSpace.jetDeriv_tmul (ν : Fin 1 ⊕ Fin 3) (a : DerivAlgebraReal) + (φ : Module.Dual ℝ GaugeBoson) : + JetComponentSpace.jetDeriv ν (a ⊗ₜ[ℝ] φ) + = (a * LagrangianTheory.dualRealJetAlgebraBasis + ({ν} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℝ] φ := rfl + +/-- Total derivatives commute on the component space: the derivative labels live in a + symmetric algebra. -/ +lemma JetComponentSpace.jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (JetComponentSpace.jetDeriv μ).comp (JetComponentSpace.jetDeriv ν) + = (JetComponentSpace.jetDeriv ν).comp (JetComponentSpace.jetDeriv μ) := by + have hmul : ∀ b c : DerivAlgebraReal, + (LinearMap.mulRight ℝ b).comp (LinearMap.mulRight ℝ c) + = LinearMap.mulRight ℝ (c * b) := + fun b c => LinearMap.ext fun x => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, + mul_assoc] + rw [JetComponentSpace.jetDeriv, JetComponentSpace.jetDeriv, ← TensorProduct.map_comp, + ← TensorProduct.map_comp, hmul, hmul, mul_comm] + +end GaugeBoson + +namespace GaugeJetAlgebra + +/-! + +## B. The total derivative on the jet algebra + +-/ + +/-- The formal total spacetime derivative on the gauge-boson jet algebra in the direction + `ν`: the derivation extending the shift `∂_s A_μ^φ ↦ ∂_{s + {ν}} A_μ^φ` of the component + functions. -/ +noncomputable def jetDeriv (ν : Fin 1 ⊕ Fin 3) : GaugeJetAlgebra →ₗ[ℝ] GaugeJetAlgebra := + SymmetricAlgebra.derivationOfLinear (GaugeBoson.JetComponentSpace.jetDeriv ν) + +@[simp] +lemma jetDeriv_ι (ν : Fin 1 ⊕ Fin 3) (x : GaugeBoson.JetComponentSpace) : + jetDeriv ν (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.ι ℝ _ (GaugeBoson.JetComponentSpace.jetDeriv ν x) := + SymmetricAlgebra.derivationOfLinear_ι _ x + +@[simp] +lemma jetDeriv_one (ν : Fin 1 ⊕ Fin 3) : jetDeriv ν (1 : GaugeJetAlgebra) = 0 := + SymmetricAlgebra.derivationOfLinear_one _ + +@[simp] +lemma jetDeriv_algebraMap (ν : Fin 1 ⊕ Fin 3) (r : ℝ) : + jetDeriv ν (algebraMap ℝ GaugeJetAlgebra r) = 0 := + SymmetricAlgebra.derivationOfLinear_algebraMap _ r + +/-- The total derivative is a derivation: the Leibniz rule. -/ +lemma jetDeriv_mul (ν : Fin 1 ⊕ Fin 3) (x y : GaugeJetAlgebra) : + jetDeriv ν (x * y) = jetDeriv ν x * y + x * jetDeriv ν y := + SymmetricAlgebra.derivationOfLinear_mul _ x y + +/-- Mixed partials agree on the jet algebra. -/ +lemma jetDeriv_comm_apply (μ ν : Fin 1 ⊕ Fin 3) (x : GaugeJetAlgebra) : + jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := + SymmetricAlgebra.derivationOfLinear_comm_apply + (GaugeBoson.JetComponentSpace.jetDeriv_comm μ ν) x + +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv μ).comp (jetDeriv ν) = (jetDeriv ν).comp (jetDeriv μ) := + LinearMap.ext fun x => jetDeriv_comm_apply μ ν x + +/-! + +## C. The iterated total derivative + +-/ + +instance : RightCommutative + (fun (D : GaugeJetAlgebra →ₗ[ℝ] GaugeJetAlgebra) (μ : Fin 1 ⊕ Fin 3) => + D.comp (jetDeriv μ)) where + right_comm D μ ν := by + show (D.comp (jetDeriv μ)).comp (jetDeriv ν) = (D.comp (jetDeriv ν)).comp (jetDeriv μ) + rw [LinearMap.comp_assoc, LinearMap.comp_assoc, jetDeriv_comm] + +/-- The iterated total derivative `∂_s` along a multiset `s` of directions, well defined + because the directional derivatives commute. -/ +noncomputable def iteratedJetDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeJetAlgebra →ₗ[ℝ] GaugeJetAlgebra := + s.foldl (fun D μ => D.comp (jetDeriv μ)) LinearMap.id + +@[simp] +lemma iteratedJetDeriv_zero : + iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) = LinearMap.id := rfl + +/-- Any initial map factors out of the fold defining the iterated derivative. -/ +lemma foldl_comp_eq (s : Multiset (Fin 1 ⊕ Fin 3)) : + ∀ D : GaugeJetAlgebra →ₗ[ℝ] GaugeJetAlgebra, + s.foldl (fun D μ => D.comp (jetDeriv μ)) D = D ∘ₗ iteratedJetDeriv s := by + induction s using Multiset.induction_on with + | empty => + intro D + rw [iteratedJetDeriv_zero] + rfl + | cons ν t ih => + intro D + rw [iteratedJetDeriv, Multiset.foldl_cons, Multiset.foldl_cons, ih, ih, + LinearMap.id_comp, LinearMap.comp_assoc] + +lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (μ ::ₘ s) = jetDeriv μ ∘ₗ iteratedJetDeriv s := by + rw [iteratedJetDeriv, Multiset.foldl_cons, foldl_comp_eq, LinearMap.id_comp] + +@[simp] +lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedJetDeriv ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = jetDeriv μ := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, iteratedJetDeriv_cons, + iteratedJetDeriv_zero, LinearMap.comp_id] + +/-- Differentiating along `s + t` is differentiating along `t` and then along `s`. -/ +lemma iteratedJetDeriv_add (s t : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (s + t) = iteratedJetDeriv t ∘ₗ iteratedJetDeriv s := by + induction t using Multiset.induction_on with + | empty => rw [add_zero, iteratedJetDeriv_zero, LinearMap.id_comp] + | cons μ t ih => + rw [show s + μ ::ₘ t = μ ::ₘ (s + t) from by + rw [← Multiset.singleton_add, ← Multiset.singleton_add, ← add_assoc, + add_comm s ({μ} : Multiset (Fin 1 ⊕ Fin 3)), add_assoc], + iteratedJetDeriv_cons, ih, iteratedJetDeriv_cons, LinearMap.comp_assoc] + +/-- On a component function the iterated derivative writes the derivative symbol `∂_s` + into the derivative label. -/ +lemma iteratedJetDeriv_ι (s : Multiset (Fin 1 ⊕ Fin 3)) (a : DerivAlgebraReal) + (φ : Module.Dual ℝ GaugeBoson) : + iteratedJetDeriv s (SymmetricAlgebra.ι ℝ _ (a ⊗ₜ[ℝ] φ)) + = SymmetricAlgebra.ι ℝ _ + ((a * LagrangianTheory.dualRealJetAlgebraBasis s) ⊗ₜ[ℝ] φ) := by + induction s using Multiset.induction_on generalizing a with + | empty => + rw [iteratedJetDeriv_zero, LinearMap.id_apply, + LagrangianTheory.dualRealJetAlgebraBasis_nil, mul_one] + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_ι, + GaugeBoson.JetComponentSpace.jetDeriv_tmul, mul_assoc, + LagrangianTheory.dualRealJetAlgebraBasis_mul, + show s + ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ s from by + rw [add_comm, Multiset.singleton_add]] + +/-- **The derivative generator `∂_s A_μ^φ`**: the iterated derivative of the gauge-field + component function. -/ +lemma iteratedJetDeriv_ofA (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + iteratedJetDeriv s (ofA μ φ) + = SymmetricAlgebra.ι ℝ _ + (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] + GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ) φ) := by + rw [ofA_apply, ofComponent_apply, iteratedJetDeriv_ι, one_mul] + +/-! + +## D. Generation by the gauge fields and their derivatives + +-/ + +/-- Every covector on the gauge-boson target space decomposes along the Lorentz coordinate + directions into component covectors: the spacetime index is expanded in the coordinate + basis, while the adjoint index stays abstract. -/ +lemma _root_.StandardModel.GaugeBoson.dual_eq_sum_componentDual + (ψ : Module.Dual ℝ GaugeBoson) : + ψ = ∑ μ, GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ) + (ψ ∘ₗ GaugeBoson.valLinEquiv.symm.toLinearMap ∘ₗ + TensorProduct.mk ℝ Lorentz.CoVector GaugeAlgebra (Lorentz.CoVector.basis μ)) := by + refine LinearMap.ext fun v => ?_ + obtain ⟨m⟩ := v + induction m using TensorProduct.induction_on with + | zero => + rw [show (⟨0⟩ : GaugeBoson) = 0 from rfl] + simp + | tmul x a => + rw [LinearMap.sum_apply] + have hx : (⟨x ⊗ₜ[ℝ] a⟩ : GaugeBoson) + = ∑ μ, Lorentz.CoVector.basis.dualBasis μ x • + (⟨Lorentz.CoVector.basis μ ⊗ₜ[ℝ] a⟩ : GaugeBoson) := by + apply GaugeBoson.valLinEquiv.injective + rw [map_sum] + conv_lhs => + rw [GaugeBoson.valLinEquiv_apply, + show (⟨x ⊗ₜ[ℝ] a⟩ : GaugeBoson).val = x ⊗ₜ[ℝ] a from rfl, + ← Lorentz.CoVector.basis.sum_repr x, TensorProduct.sum_tmul] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_smul, GaugeBoson.valLinEquiv_apply, + show (⟨Lorentz.CoVector.basis μ ⊗ₜ[ℝ] a⟩ : GaugeBoson).val + = Lorentz.CoVector.basis μ ⊗ₜ[ℝ] a from rfl, ← TensorProduct.smul_tmul', + Module.Basis.dualBasis_apply] + conv_lhs => rw [hx, map_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [map_smul, GaugeBoson.componentDual_apply_val_tmul, smul_eq_mul] + rfl + | add m₁ m₂ h₁ h₂ => + simp only [show (⟨m₁ + m₂⟩ : GaugeBoson) = (⟨m₁⟩ : GaugeBoson) + ⟨m₂⟩ from rfl, + map_add, LinearMap.sum_apply] at h₁ h₂ ⊢ + rw [h₁, h₂, ← Finset.sum_add_distrib] + +set_option maxHeartbeats 1000000 in +/-- **The jet algebra is generated by the gauge fields and their derivatives.** Every + element is a polynomial in the derivative generators `∂_s A_μ^φ` — nothing else is + available to write down for the gauge sector of a Lagrangian. -/ +theorem adjoin_iteratedJetDeriv_eq_top : + Algebra.adjoin ℝ + (⋃ s : Multiset (Fin 1 ⊕ Fin 3), ⋃ μ : Fin 1 ⊕ Fin 3, + Set.range (fun φ : Module.Dual ℝ GaugeAlgebra => iteratedJetDeriv s (ofA μ φ))) + = (⊤ : Subalgebra ℝ GaugeJetAlgebra) := by + set S : Set GaugeJetAlgebra := + ⋃ s : Multiset (Fin 1 ⊕ Fin 3), ⋃ μ : Fin 1 ⊕ Fin 3, + Set.range (fun φ : Module.Dual ℝ GaugeAlgebra => iteratedJetDeriv s (ofA μ φ)) + with hS + /- The derivative generators lie in the adjoined set. -/ + have hgen : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + SymmetricAlgebra.ι ℝ _ (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] + GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ) φ) + ∈ Algebra.adjoin ℝ S := by + intro s μ φ + rw [← iteratedJetDeriv_ofA, hS] + exact Algebra.subset_adjoin + (Set.mem_iUnion.mpr ⟨s, Set.mem_iUnion.mpr ⟨μ, ⟨φ, rfl⟩⟩⟩) + /- Any covector slot: expand the spacetime index in the coordinate basis. -/ + have hcomp : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (ψ : Module.Dual ℝ GaugeBoson), + SymmetricAlgebra.ι ℝ _ (LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ) + ∈ Algebra.adjoin ℝ S := by + intro s ψ + rw [show LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] ψ + = ∑ μ, LagrangianTheory.dualRealJetAlgebraBasis s ⊗ₜ[ℝ] + GaugeBoson.componentDual (Lorentz.CoVector.basis.dualBasis μ) + (ψ ∘ₗ GaugeBoson.valLinEquiv.symm.toLinearMap ∘ₗ + TensorProduct.mk ℝ Lorentz.CoVector GaugeAlgebra + (Lorentz.CoVector.basis μ)) from by + conv_lhs => rw [GaugeBoson.dual_eq_sum_componentDual ψ] + rw [TensorProduct.tmul_sum], map_sum] + exact Subalgebra.sum_mem _ fun μ _ => hgen s μ _ + /- The derivative monomials span the `DerivAlgebraReal` factor. -/ + refine top_le_iff.mp ?_ + rw [← adjoin_ι_eq_top] + refine Algebra.adjoin_le ?_ + rintro _ ⟨x, rfl⟩ + induction x using TensorProduct.induction_on with + | zero => rw [map_zero]; exact zero_mem _ + | add y z hy hz => rw [map_add]; exact add_mem hy hz + | tmul a ψ => + have ha : a ∈ Submodule.span ℝ (Set.range LagrangianTheory.dualRealJetAlgebraBasis) := by + rw [LagrangianTheory.dualRealJetAlgebraBasis.span_eq]; trivial + induction ha using Submodule.span_induction with + | mem b hb => obtain ⟨s, rfl⟩ := hb; exact hcomp s ψ + | zero => rw [TensorProduct.zero_tmul, map_zero]; exact zero_mem _ + | add b c _ _ hb hc => rw [TensorProduct.add_tmul, map_add]; exact add_mem hb hc + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul] + exact Subalgebra.smul_mem _ hb c + +/-! + +## E. The derivative on the complexification + +-/ + +/-- The formal total derivative on the complexified gauge-boson jet algebra, by base + change. This is the derivative the ambient Lagrangian theory uses. -/ +noncomputable def complexJetDeriv (ν : Fin 1 ⊕ Fin 3) : + ℂ ⊗[ℝ] GaugeJetAlgebra →ₗ[ℂ] ℂ ⊗[ℝ] GaugeJetAlgebra := + LinearMap.baseChange ℂ (jetDeriv ν) + +@[simp] +lemma complexJetDeriv_tmul (ν : Fin 1 ⊕ Fin 3) (z : ℂ) (x : GaugeJetAlgebra) : + complexJetDeriv ν (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] jetDeriv ν x := rfl + +set_option maxHeartbeats 1000000 in +/-- The Leibniz rule on the complexification. -/ +lemma complexJetDeriv_mul (ν : Fin 1 ⊕ Fin 3) (x y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + complexJetDeriv ν (x * y) + = complexJetDeriv ν x * y + x * complexJetDeriv ν y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => + rw [add_mul, map_add, map_add, h₁, h₂, add_mul, add_mul] + abel + | tmul z₁ a₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => + rw [mul_add, map_add, map_add, h₁, h₂, mul_add, mul_add] + abel + | tmul z₂ a₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, complexJetDeriv_tmul, complexJetDeriv_tmul, + complexJetDeriv_tmul, jetDeriv_mul, TensorProduct.tmul_add, + Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul] + +/-- The complexified total derivatives commute. -/ +lemma complexJetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (complexJetDeriv μ).comp (complexJetDeriv ν) + = (complexJetDeriv ν).comp (complexJetDeriv μ) := by + rw [complexJetDeriv, complexJetDeriv, ← LinearMap.baseChange_comp, + ← LinearMap.baseChange_comp, jetDeriv_comm] + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/LorentzAction.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/LorentzAction.lean new file mode 100644 index 000000000..91405ae33 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/LorentzAction.lean @@ -0,0 +1,307 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.JetDeriv +public import Physlib.Relativity.IsLorentzDeriv +/-! +# The Lorentz action on the gauge-boson jet algebra + +## i. Overview + +The Lorentz group acts on the jet algebra of the gauge bosons by the symmetric-algebra +functor applied to its action on the jet component space: the derivative labels transform +in `DerivAlgebraReal` and the target index contragrediently through the covector action on +`GaugeBoson`. The formal total derivative is a Lorentz vector for this action; on the +complexification this is packaged as a `Lorentz.IsLorentzDeriv` instance, giving access to +the boost-weight machinery. + +## ii. Key results + +- `GaugeBoson.JetComponentSpace.repLorentzGroup` : the Lorentz action on the component + space. +- `GaugeJetAlgebra.repLorentzGroup` : the Lorentz action on the jet algebra. +- `GaugeJetAlgebra.repLorentzGroup_jetDeriv` : the total derivative is a Lorentz vector. +- `GaugeJetAlgebra.complexRepLorentzGroup` : the action on the complexification. +- `GaugeJetAlgebra.instIsLorentzDeriv` : the `Lorentz.IsLorentzDeriv` instance. + +## iii. Table of contents + +- A. The Lorentz action on the component space + - A.1. Covariance of the derivative shift +- B. The Lorentz action on the jet algebra +- C. Lorentz covariance of the total derivative +- D. The complexified action + +-/ + +@[expose] public section + +set_option maxHeartbeats 1000000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +/-! + +## A. The Lorentz action on the component space + +-/ + +namespace GaugeBoson + +/-- The Lorentz action on the jet component space of the gauge bosons: the derivative + label transforms in `DerivAlgebraReal`, the target index contragrediently. -/ +noncomputable def JetComponentSpace.repLorentzGroup : + Representation ℝ SL(2,ℂ) JetComponentSpace := + DerivAlgebraReal.repLorentzGroup.tprod GaugeBoson.repLorentzGroup.dual + +/-! + +### A.1. Covariance of the derivative shift + +-/ + +/-- The Lorentz action on the singleton derivative symbol: the derivative slot transforms + by the columns of the Lorentz matrix. -/ +lemma _root_.StandardModel.DerivAlgebraReal.repLorentzGroup_basis_singleton + (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + DerivAlgebraReal.repLorentzGroup Λ + (LagrangianTheory.dualRealJetAlgebraBasis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) • + LagrangianTheory.dualRealJetAlgebraBasis ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [LagrangianTheory.dualRealJetAlgebraBasis_singleton, + DerivAlgebraReal.repLorentzGroup_apply_ι, Lorentz.CoVector.sl2Rep_dual_dualBasis, + map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, LagrangianTheory.dualRealJetAlgebraBasis_singleton] + +/-- **The derivative shift is a Lorentz vector on the component space**: appending `∂_μ` + and then acting is acting and then appending the transformed `∂_μ`. -/ +lemma JetComponentSpace.repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace) : + JetComponentSpace.repLorentzGroup Λ (JetComponentSpace.jetDeriv μ v) = + ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) • + JetComponentSpace.jetDeriv a (JetComponentSpace.repLorentzGroup Λ v) := by + induction v using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => + rw [map_add, map_add, map_add, hx, hy, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + | tmul q f => + rw [JetComponentSpace.jetDeriv_tmul, + show JetComponentSpace.repLorentzGroup Λ + ((q * LagrangianTheory.dualRealJetAlgebraBasis + ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℝ] f) + = (DerivAlgebraReal.repLorentzGroup Λ + (q * LagrangianTheory.dualRealJetAlgebraBasis + ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) ⊗ₜ[ℝ] + (GaugeBoson.repLorentzGroup.dual Λ f) from rfl, + DerivAlgebraReal.repLorentzGroup_apply_mul, + DerivAlgebraReal.repLorentzGroup_basis_singleton, Finset.mul_sum, + TensorProduct.sum_tmul] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [mul_smul_comm, ← TensorProduct.smul_tmul', + show JetComponentSpace.repLorentzGroup Λ (q ⊗ₜ[ℝ] f) + = (DerivAlgebraReal.repLorentzGroup Λ q) ⊗ₜ[ℝ] + (GaugeBoson.repLorentzGroup.dual Λ f) from rfl, + JetComponentSpace.jetDeriv_tmul] + +end GaugeBoson + +namespace GaugeJetAlgebra + +/-! + +## B. The Lorentz action on the jet algebra + +-/ + +/-- **The Lorentz action on the gauge-boson jet algebra**: the symmetric-algebra functor + applied to the Lorentz action on the jet component space. -/ +noncomputable def repLorentzGroup : Representation ℝ SL(2,ℂ) GaugeJetAlgebra where + toFun Λ := + (SymmetricAlgebra.map (GaugeBoson.JetComponentSpace.repLorentzGroup Λ)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, SymmetricAlgebra.map_id, AlgHom.toLinearMap_id] + map_mul' Λ₁ Λ₂ := by + simp only [map_mul, Module.End.mul_eq_comp, ← SymmetricAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repLorentzGroup_apply (Λ : SL(2,ℂ)) (x : GaugeJetAlgebra) : + repLorentzGroup Λ x = + SymmetricAlgebra.map (GaugeBoson.JetComponentSpace.repLorentzGroup Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + repLorentzGroup Λ (1 : GaugeJetAlgebra) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : GaugeJetAlgebra) : + repLorentzGroup Λ (x * y) = repLorentzGroup Λ x * repLorentzGroup Λ y := by + simp [repLorentzGroup_apply] + +@[simp] +lemma repLorentzGroup_ι (Λ : SL(2,ℂ)) (v : GaugeBoson.JetComponentSpace) : + repLorentzGroup Λ (SymmetricAlgebra.ι ℝ _ v) = + SymmetricAlgebra.ι ℝ _ (GaugeBoson.JetComponentSpace.repLorentzGroup Λ v) := by + rw [repLorentzGroup_apply, SymmetricAlgebra.map_apply_ι] + +/-! + +## C. Lorentz covariance of the total derivative + +-/ + +/-- **The total derivative on the gauge-boson jet algebra is a Lorentz vector.** -/ +lemma repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (x : GaugeJetAlgebra) : + repLorentzGroup Λ (jetDeriv μ x) = + ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) • + jetDeriv a (repLorentzGroup Λ x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => + rw [jetDeriv_algebraMap, map_zero] + refine (Finset.sum_eq_zero fun a _ => ?_).symm + rw [Algebra.algebraMap_eq_smul_one, map_smul, repLorentzGroup_apply_one, map_smul, + jetDeriv_one, smul_zero, smul_zero] + | ι v => + rw [jetDeriv_ι, repLorentzGroup_ι, repLorentzGroup_ι, + GaugeBoson.JetComponentSpace.repLorentzGroup_jetDeriv, map_sum] + exact Finset.sum_congr rfl fun a _ => by rw [map_smul, jetDeriv_ι] + | mul a b ha hb => + rw [jetDeriv_mul, map_add, repLorentzGroup_apply_mul, repLorentzGroup_apply_mul, ha, hb, + Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib, repLorentzGroup_apply_mul] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [jetDeriv_mul, smul_add, smul_mul_assoc, mul_smul_comm] + | add a b ha hb => + rw [map_add, map_add, map_add, ha, hb, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + +/-! + +## D. The complexified action + +-/ + +/-- The Lorentz action on the complexified gauge-boson jet algebra, by base change. -/ +noncomputable def complexRepLorentzGroup : + Representation ℂ SL(2,ℂ) (ℂ ⊗[ℝ] GaugeJetAlgebra) where + toFun Λ := LinearMap.baseChange ℂ (repLorentzGroup Λ) + map_one' := by + rw [map_one, Module.End.one_eq_id, LinearMap.baseChange_id, Module.End.one_eq_id] + map_mul' Λ₁ Λ₂ := by + rw [map_mul, Module.End.mul_eq_comp, LinearMap.baseChange_comp, Module.End.mul_eq_comp] + +@[simp] +lemma complexRepLorentzGroup_tmul (Λ : SL(2,ℂ)) (z : ℂ) (x : GaugeJetAlgebra) : + complexRepLorentzGroup Λ (z ⊗ₜ[ℝ] x) = z ⊗ₜ[ℝ] repLorentzGroup Λ x := rfl + +lemma complexRepLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + complexRepLorentzGroup Λ (x * y) + = complexRepLorentzGroup Λ x * complexRepLorentzGroup Λ y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => rw [add_mul, map_add, map_add, h₁, h₂, add_mul] + | tmul z₁ a₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => rw [mul_add, map_add, map_add, h₁, h₂, mul_add] + | tmul z₂ a₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, complexRepLorentzGroup_tmul, + complexRepLorentzGroup_tmul, complexRepLorentzGroup_tmul, + repLorentzGroup_apply_mul, Algebra.TensorProduct.tmul_mul_tmul] + +/-- **The complexified total derivative is a Lorentz vector.** -/ +lemma complexRepLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (x : ℂ ⊗[ℝ] GaugeJetAlgebra) : + complexRepLorentzGroup Λ (complexJetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + complexJetDeriv a (complexRepLorentzGroup Λ x) := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => + rw [map_add, map_add, map_add, hx, hy, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + | tmul z a => + rw [complexJetDeriv_tmul, complexRepLorentzGroup_tmul, repLorentzGroup_jetDeriv, + TensorProduct.tmul_sum] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [TensorProduct.tmul_smul, complexRepLorentzGroup_tmul, complexJetDeriv_tmul, + show ((((Lorentz.SL2C.toLorentzGroup Λ).1 c μ : ℝ)) : ℂ) + = algebraMap ℝ ℂ ((Lorentz.SL2C.toLorentzGroup Λ).1 c μ) from rfl, + algebraMap_smul] + +/-- The complexified total derivatives form a Lorentz derivative, giving access to the + boost-weight machinery. -/ +instance instIsLorentzDeriv : + Lorentz.IsLorentzDeriv complexRepLorentzGroup complexJetDeriv where + rep_deriv := complexRepLorentzGroup_jetDeriv _ _ _ + +/-! + +## E. The Lorentz law of the gauge-field generators + +-/ + +/-- The contragredient Lorentz action passes through a component covector to its spacetime + slot: the adjoint index is Lorentz-inert. -/ +lemma _root_.StandardModel.GaugeBoson.repLorentzGroup_dual_componentDual (Λ : SL(2,ℂ)) + (ω : Module.Dual ℝ Lorentz.CoVector) (φ : Module.Dual ℝ GaugeAlgebra) : + GaugeBoson.repLorentzGroup.dual Λ (GaugeBoson.componentDual ω φ) + = GaugeBoson.componentDual (Lorentz.CoVector.sl2Rep.dual Λ ω) φ := by + refine LinearMap.ext fun v => ?_ + obtain ⟨m⟩ := v + induction m using TensorProduct.induction_on with + | zero => + rw [show (⟨0⟩ : GaugeBoson) = 0 from rfl, map_zero, map_zero] + | tmul x a => + rw [Representation.dual_apply, Module.Dual.transpose_apply, LinearMap.comp_apply, + show GaugeBoson.repLorentzGroup Λ⁻¹ (⟨x ⊗ₜ[ℝ] a⟩ : GaugeBoson) + = ⟨(Lorentz.CoVector.sl2Rep Λ⁻¹ x) ⊗ₜ[ℝ] a⟩ from rfl, + GaugeBoson.componentDual_apply_val_tmul, GaugeBoson.componentDual_apply_val_tmul, + Representation.dual_apply, Module.Dual.transpose_apply, LinearMap.comp_apply] + | add m₁ m₂ h₁ h₂ => + rw [show (⟨m₁ + m₂⟩ : GaugeBoson) = (⟨m₁⟩ : GaugeBoson) + ⟨m₂⟩ from rfl, map_add, + map_add, h₁, h₂] + +/-- **The gauge field is a Lorentz covector**: the generator `A_μ^φ` mixes into the `A_a^φ` + by the columns of the Lorentz matrix, with the adjoint index untouched. -/ +lemma repLorentzGroup_ofA (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + repLorentzGroup Λ (ofA μ φ) + = ∑ a, ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) • ofA a φ := by + rw [ofA_apply, ofComponent_apply, repLorentzGroup_ι, + show GaugeBoson.JetComponentSpace.repLorentzGroup Λ + ((1 : DerivAlgebraReal) ⊗ₜ[ℝ] GaugeBoson.componentDual + (Lorentz.CoVector.basis.dualBasis μ) φ) + = (DerivAlgebraReal.repLorentzGroup Λ (1 : DerivAlgebraReal)) ⊗ₜ[ℝ] + (GaugeBoson.repLorentzGroup.dual Λ (GaugeBoson.componentDual + (Lorentz.CoVector.basis.dualBasis μ) φ)) from rfl, + DerivAlgebraReal.repLorentzGroup_apply_one, + GaugeBoson.repLorentzGroup_dual_componentDual, + Lorentz.CoVector.sl2Rep_dual_dualBasis, map_sum, LinearMap.sum_apply, + TensorProduct.tmul_sum, map_sum] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [map_smul, LinearMap.smul_apply, TensorProduct.tmul_smul, map_smul, ofA_apply, + ofComponent_apply] + +/-- The Lorentz law of the gauge-field generators on the complexification. -/ +lemma complexRepLorentzGroup_one_tmul_ofA (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + complexRepLorentzGroup Λ ((1 : ℂ) ⊗ₜ[ℝ] ofA μ φ) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + ((1 : ℂ) ⊗ₜ[ℝ] ofA a φ) := by + rw [complexRepLorentzGroup_tmul, repLorentzGroup_ofA, TensorProduct.tmul_sum] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [TensorProduct.tmul_smul, + show ((((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ)) : ℂ) + = algebraMap ℝ ℂ ((Lorentz.SL2C.toLorentzGroup Λ).1 a μ) from rfl, + algebraMap_smul] + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/MassDim.lean b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/MassDim.lean new file mode 100644 index 000000000..546642472 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeBosons/GaugeJetAlgebra/MassDim.lean @@ -0,0 +1,148 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.JetDeriv +/-! +# Mass dimension on the gauge-boson jet algebra + +## i. Overview + +The mass dimension of the gauge bosons is tracked multiplicatively through the +*mass-weight scaling*: the algebra endomorphism multiplying each generator `∂_s A_μ^φ` by +`c ^ (2 + 2 |s|)` — the gauge field has mass dimension one, i.e. mass weight two, and each +derivative adds mass weight two. A monomial of total mass weight `n` is scaled by `c ^ n`, +so the scaling records the mass-weight grading of the jet algebra. This mirrors +`Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim`, on the real, single-half +component space of the gauge bosons. + +## ii. Key results + +- `GaugeBoson.JetComponentSpace.massWeightScale` : the scaling on the component space. +- `GaugeJetAlgebra.massWeightScale` : the mass-weight scaling. +- `GaugeJetAlgebra.massWeightScale_ofA` : the gauge field carries mass weight two. +- `GaugeJetAlgebra.massWeightScale_jetDeriv` : a derivative adds mass weight two. +- `GaugeJetAlgebra.massWeightScale_iteratedJetDeriv` : `∂_s` adds mass weight `2 |s|`. + +## iii. Table of contents + +- A. The mass-weight scaling on the component space +- B. The mass-weight scaling on the jet algebra +- C. The mass weight of the gauge field and its derivatives + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +/-! + +## A. The mass-weight scaling on the component space + +-/ + +namespace GaugeBoson + +/-- The mass-weight scaling on the jet component space of the gauge bosons: the generator + `∂_s A_μ^φ` is scaled by `c ^ (2 + 2 |s|)`, through the derivative-degree scaling + `DerivAlgebraReal.gradeScale` on the derivative label. -/ +noncomputable def JetComponentSpace.massWeightScale (c : ℝ) : + JetComponentSpace →ₗ[ℝ] JetComponentSpace := + c ^ 2 • TensorProduct.map (DerivAlgebraReal.gradeScale (c ^ 2)).toLinearMap LinearMap.id + +lemma JetComponentSpace.massWeightScale_tmul (c : ℝ) (a : DerivAlgebraReal) + (φ : Module.Dual ℝ GaugeBoson) : + JetComponentSpace.massWeightScale c (a ⊗ₜ[ℝ] φ) + = c ^ 2 • (DerivAlgebraReal.gradeScale (c ^ 2) a ⊗ₜ[ℝ] φ) := rfl + +/-- **The derivative shift carries mass weight two** on the component space. -/ +lemma JetComponentSpace.massWeightScale_jetDeriv (c : ℝ) (μ : Fin 1 ⊕ Fin 3) + (v : JetComponentSpace) : + JetComponentSpace.massWeightScale c (JetComponentSpace.jetDeriv μ v) + = c ^ 2 • JetComponentSpace.jetDeriv μ (JetComponentSpace.massWeightScale c v) := by + induction v using TensorProduct.induction_on with + | zero => simp only [map_zero, smul_zero] + | add x y hx hy => simp only [map_add, hx, hy, smul_add] + | tmul a φ => + rw [JetComponentSpace.jetDeriv_tmul, JetComponentSpace.massWeightScale_tmul, map_mul, + LagrangianTheory.dualRealJetAlgebraBasis_singleton, + DerivAlgebraReal.gradeScale_ι, ← LagrangianTheory.dualRealJetAlgebraBasis_singleton, + JetComponentSpace.massWeightScale_tmul, map_smul, JetComponentSpace.jetDeriv_tmul, + mul_smul_comm, TensorProduct.smul_tmul', smul_smul, smul_smul, mul_comm (c ^ 2)] + rfl + +end GaugeBoson + +namespace GaugeJetAlgebra + +/-! + +## B. The mass-weight scaling on the jet algebra + +-/ + +/-- **The mass-weight scaling on the gauge-boson jet algebra**: the algebra endomorphism + scaling the generator `∂_s A_μ^φ` by `c ^ (2 + 2 |s|)`, the functorial lift of the + scaling on the jet component space. -/ +noncomputable def massWeightScale (c : ℝ) : GaugeJetAlgebra →ₐ[ℝ] GaugeJetAlgebra := + SymmetricAlgebra.map (GaugeBoson.JetComponentSpace.massWeightScale c) + +@[simp] +lemma massWeightScale_ι (c : ℝ) (x : GaugeBoson.JetComponentSpace) : + massWeightScale c (SymmetricAlgebra.ι ℝ _ x) + = SymmetricAlgebra.ι ℝ _ (GaugeBoson.JetComponentSpace.massWeightScale c x) := + SymmetricAlgebra.map_apply_ι _ x + +/-! + +## C. The mass weight of the gauge field and its derivatives + +-/ + +/-- **The gauge field carries mass weight two** — mass dimension one. -/ +@[simp] +lemma massWeightScale_ofA (c : ℝ) (μ : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + massWeightScale c (ofA μ φ) = c ^ 2 • ofA μ φ := by + rw [ofA_apply, ofComponent_apply, massWeightScale_ι, + GaugeBoson.JetComponentSpace.massWeightScale_tmul, map_one, map_smul] + +/-- **A total derivative adds mass weight two.** -/ +lemma massWeightScale_jetDeriv (c : ℝ) (μ : Fin 1 ⊕ Fin 3) (x : GaugeJetAlgebra) : + massWeightScale c (jetDeriv μ x) = c ^ 2 • jetDeriv μ (massWeightScale c x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => rw [jetDeriv_algebraMap, map_zero, AlgHom.commutes, jetDeriv_algebraMap, + smul_zero] + | ι v => + rw [jetDeriv_ι, massWeightScale_ι, massWeightScale_ι, jetDeriv_ι, ← map_smul] + exact congrArg (SymmetricAlgebra.ι ℝ _) + (GaugeBoson.JetComponentSpace.massWeightScale_jetDeriv c μ v) + | mul a b ha hb => + simp only [jetDeriv_mul, map_add, map_mul, ha, hb, smul_add, smul_mul_assoc, + mul_smul_comm] + | add a b ha hb => simp only [map_add, ha, hb, smul_add] + +/-- **The iterated derivative `∂_s` adds mass weight `2 |s|`.** -/ +lemma massWeightScale_iteratedJetDeriv (c : ℝ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : GaugeJetAlgebra) : + massWeightScale c (iteratedJetDeriv s x) + = c ^ (2 * Multiset.card s) • iteratedJetDeriv s (massWeightScale c x) := by + induction s using Multiset.induction_on generalizing x with + | empty => simp + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, massWeightScale_jetDeriv, + show massWeightScale c (iteratedJetDeriv s x) + = c ^ (2 * Multiset.card s) • iteratedJetDeriv s (massWeightScale c x) from ih x, + map_smul, LinearMap.comp_apply, smul_smul, ← pow_add] + congr 2 + rw [Multiset.card_cons] + ring + +end GaugeJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean b/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean new file mode 100644 index 000000000..41f6cc3b4 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/GaugeWeightDecomposition.lean @@ -0,0 +1,719 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Mathlib.LinearAlgebra.Eigenspace.Basic +public import Mathlib.Analysis.Real.Pi.Irrational +/-! +# Gauge weight decompositions + +## i. Overview + +The operators that may appear in a Standard Model Lagrangian are those the gauge group leaves +fixed, and finding them means searching a large space of composite operators. + +The maximal torus of the gauge group is four-dimensional, and a **gauge weight** is the +quadruple of charges + + `(colour₁, colour₂, isospin, hypercharge) : ℤ × ℤ × ℤ × ℤ`, + +recording how a vector scales under four chosen elements of it. Two count colour, one counts +weak isospin normalized as `2T₃`, and one counts hypercharge normalized as `6Y`. A **gauge +weight decomposition** of a submodule `V` presents it as a finitely supported family of +subspaces on each of which those four elements act by one such character. + +Carrying all four charges at once costs nothing, since the four elements commute. They lie in +different factors of the product group, and the two colour elements are both diagonal, so the +four gradings are simultaneously realizable. An invariant operator is fixed by the whole gauge +group, so in particular by these four elements, so it carries zero weight and the search can +be confined to the zero-weight piece. + + +## ii. Key results + +- `gaugeTorusGen` : the four commuting torus generators. +- `GaugeWeight` : the quadruple of charges measured against them. +- `GaugeWeightDecomposition` : a finitely supported family of pure-weight subspaces with + supremum `V`. +- `GaugeWeightDecomposition.sup` : decompositions combine one weight at a time along + `V ⊔ V'`. +- `GaugeWeightDecomposition.mul` : weights add under multiplication, decomposing `V * V'`. +- `GaugeWeightDecomposition.piece_eq_inf` : the pieces are cut out of `V` by the torus alone. +- `GaugeWeightDecomposition.mem_zero_of_invariant` : a gauge-invariant element lies in the + zero-weight piece. + +## iii. Table of contents + +- A. The scalar `exp i` and the torus generators +- B. The four torus generators and gauge weights +- C. Gauge weight decompositions +- D. Joins +- E. Products +- F. Invariants + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix Pointwise + +/-! +## A. The scalar `exp i` and the torus generators + +Every charge here is measured by one scalar. The unit complex number `exp i` has infinite +order, since `π` is irrational, so its integer powers are pairwise distinct and a single +element of the torus already separates all the weights in a given direction. + +The torus generators are built by placing `exp i` and its inverse on a diagonal. The maximal +torus of `SU(3)` is two-dimensional, so colour is a two-component charge and needs the two +elements `diag (exp i, exp (-i), 1)` and `diag (1, exp i, exp (-i))`. Weak isospin needs one, +`diag (exp i, exp (-i))`. Each lies in its special unitary group because the diagonal entries +have modulus one and multiply to one. Hypercharge needs no matrix, since its factor of the +gauge group is already the unit circle. + +The generators are elements of the group, and the purity of a weight space is recorded by a +character equation `rep g x = c • x`. +-/ + +/-- The unitary scalar `exp i`, a point of the unit circle of infinite order. -/ +noncomputable def expI : unitary ℂ := + ⟨Complex.exp Complex.I, by + have hstar : star (Complex.exp Complex.I) = Complex.exp (-Complex.I) := by + rw [show star (Complex.exp Complex.I) + = (starRingEnd ℂ) (Complex.exp Complex.I) from rfl, ← Complex.exp_conj, + Complex.conj_I] + constructor + · rw [hstar, ← Complex.exp_add, neg_add_cancel, Complex.exp_zero] + · rw [hstar, ← Complex.exp_add, add_neg_cancel, Complex.exp_zero]⟩ + +/-- The powers of `exp i` are pairwise distinct, by the irrationality of `π`. -/ +lemma expI_zpow_injective : Function.Injective fun n : ℤ => ((expI : ℂ) ^ n) := by + intro a b hab + simp only [show ((expI : ℂ)) = Complex.exp Complex.I from rfl, + ← Complex.exp_int_mul] at hab + obtain ⟨k, hk⟩ := Complex.exp_eq_exp_iff_exists_int.mp hab + have hℂ : ((a : ℂ)) = b + k * (2 * (Real.pi : ℂ)) := by + refine mul_right_cancel₀ Complex.I_ne_zero ?_ + rw [hk] + ring + have hℝ : ((a : ℝ)) = b + k * (2 * Real.pi) := by + have h := congrArg Complex.re hℂ + simpa using h + rcases eq_or_ne k 0 with rfl | hk0 + · exact_mod_cast (by simpa using hℝ : ((a : ℝ)) = b) + · exfalso + refine irrational_pi ⟨(a - b) / (2 * k), ?_⟩ + have h2k : ((2 * k : ℝ)) ≠ 0 := + mul_ne_zero two_ne_zero (Int.cast_ne_zero.mpr hk0) + push_cast + rw [div_eq_iff h2k] + linarith [hℝ] + +/-- `exp i` is nonzero. -/ +lemma expI_ne_zero : ((expI : ℂ)) ≠ 0 := fun h0 => by + have h := Unitary.mul_star_self_of_mem expI.2 + rw [h0, zero_mul] at h + exact zero_ne_one h + +/-- The inverse of `exp i` is its star. -/ +lemma expI_inv_eq_star : ((expI : ℂ))⁻¹ = star (expI : ℂ) := + inv_eq_of_mul_eq_one_right (Unitary.mul_star_self_of_mem expI.2) + +/-- `exp i` times its conjugate is one. -/ +lemma expI_mul_conj : (expI : ℂ) * (starRingEnd ℂ) (expI : ℂ) = 1 := + Unitary.mul_star_self_of_mem expI.2 + +/-- The conjugate of `exp i` times `exp i` is one. -/ +lemma conj_mul_expI : (starRingEnd ℂ) (expI : ℂ) * (expI : ℂ) = 1 := + Unitary.star_mul_self_of_mem expI.2 + +/-- A diagonal matrix whose entries are unit scalars with product one lies in the special + unitary group. -/ +lemma _root_.Matrix.mem_specialUnitaryGroup_diagonal {n : Type*} [Fintype n] [DecidableEq n] + (d : n → ℂ) (hd : ∀ i, d i * star (d i) = 1) (hdet : ∏ i, d i = 1) : + Matrix.diagonal d ∈ Matrix.specialUnitaryGroup n ℂ := by + rw [Matrix.mem_specialUnitaryGroup_iff] + refine ⟨?_, ?_⟩ + · rw [Matrix.mem_unitaryGroup_iff, Matrix.star_eq_conjTranspose, + Matrix.diagonal_conjTranspose, Matrix.diagonal_mul_diagonal] + simp only [Pi.star_apply] + rw [funext hd, Matrix.diagonal_one] + · rw [Matrix.det_diagonal, hdet] + +/-- The first colour torus generator, `diag (exp i, exp (-i), 1)`. -/ +noncomputable def su3ExpIOne : specialUnitaryGroup (Fin 3) ℂ := + ⟨Matrix.diagonal ![(expI : ℂ), star (expI : ℂ), 1], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_three, expI_mul_conj])⟩ + +/-- The second colour torus generator, `diag (1, exp i, exp (-i))`. -/ +noncomputable def su3ExpITwo : specialUnitaryGroup (Fin 3) ℂ := + ⟨Matrix.diagonal ![1, (expI : ℂ), star (expI : ℂ)], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_three, expI_mul_conj])⟩ + +/-- The `SU(2)` torus element, `diag (exp i, exp (-i))`. -/ +noncomputable def su2ExpI : specialUnitaryGroup (Fin 2) ℂ := + ⟨Matrix.diagonal ![(expI : ℂ), star (expI : ℂ)], + Matrix.mem_specialUnitaryGroup_diagonal _ + (fun i => by fin_cases i <;> simp [expI_mul_conj, conj_mul_expI]) + (by simp [Fin.prod_univ_two, expI_mul_conj])⟩ + +/-- The underlying matrix of the `SU(2)` torus element. -/ +lemma su2ExpI_coe : + (su2ExpI : specialUnitaryGroup (Fin 2) ℂ).1 + = !![(expI : ℂ), 0; 0, star (expI : ℂ)] := by + ext a b + fin_cases a <;> fin_cases b <;> simp [su2ExpI, Matrix.diagonal] + +/-- The inverse torus element is `diag (exp (-i), exp i)`, so on a doublet the two components + are scaled by the reciprocal characters. -/ +lemma su2ExpI_inv_coe : + (su2ExpI⁻¹ : specialUnitaryGroup (Fin 2) ℂ).1 + = !![star (expI : ℂ), 0; 0, (expI : ℂ)] := by + rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star, su2ExpI_coe] + ext a b + fin_cases a <;> fin_cases b <;> simp + +/-! +## B. The four torus generators and gauge weights + +Weights are measured against four chosen elements of the maximal torus, one element per +direction, collected in `gaugeTorusGen`. Four suffice because of the separation in section A. + +Both abelian charges are normalized to integers. Weak isospin is measured as `2T₃`, so the two +components of a doublet carry weights `+1` and `-1`, and hypercharge as `6Y`, the smallest +rescaling under which every Standard Model hypercharge is an integer, the quark doublet at `Y = 1/6` +becoming `6Y = 1`. Integrality is what allows every eigenvalue here to be an integer power +`(exp i) ^ k` of one scalar. + +`GaugeWeight.coord` reads a weight at a given generator. It is additive, which is why charges +add when operators are multiplied, and injective, so a weight can be recovered from the four +characters by which the torus acts. +-/ + +/-- The four commuting generators of the maximal torus of the gauge group. -/ +noncomputable def gaugeTorusGen : Fin 4 → GaugeGroupI := + ![⟨su3ExpIOne, 1, 1⟩, ⟨su3ExpITwo, 1, 1⟩, ⟨1, su2ExpI, 1⟩, ⟨1, 1, expI⟩] + +/-- A **gauge weight**, the four exponents `(colour₁, colour₂, isospin, hypercharge)` + recording how a vector scales under `gaugeTorusGen`. -/ +abbrev GaugeWeight : Type := ℤ × ℤ × ℤ × ℤ + +/-- The exponent of a gauge weight against the `i`-th torus generator. -/ +def GaugeWeight.coord (w : GaugeWeight) : Fin 4 → ℤ := ![w.1, w.2.1, w.2.2.1, w.2.2.2] + +/-- The exponent at the first colour generator. -/ +@[simp] lemma GaugeWeight.coord_zero (w : GaugeWeight) : w.coord 0 = w.1 := rfl + +/-- The exponent at the second colour generator. -/ +@[simp] lemma GaugeWeight.coord_one (w : GaugeWeight) : w.coord 1 = w.2.1 := rfl + +/-- The exponent at the isospin generator, normalized as `2T₃`. -/ +@[simp] lemma GaugeWeight.coord_two (w : GaugeWeight) : w.coord 2 = w.2.2.1 := rfl + +/-- The exponent at the hypercharge generator, normalized as `6Y`. -/ +@[simp] lemma GaugeWeight.coord_three (w : GaugeWeight) : w.coord 3 = w.2.2.2 := rfl + +/-- The zero gauge weight has vanishing exponent against every torus generator. -/ +@[simp] lemma GaugeWeight.zero_coord (i : Fin 4) : (0 : GaugeWeight).coord i = 0 := by + fin_cases i <;> rfl + +/-- Weights add coordinatewise. With `zero_coord` this says `coord` is additive, which is + what makes gauge weights add under multiplication. -/ +lemma GaugeWeight.coord_add (w w' : GaugeWeight) (i : Fin 4) : + (w + w').coord i = w.coord i + w'.coord i := by + fin_cases i <;> rfl + +/-- **A gauge weight is determined by its four exponents.** This is what lets a weight be + recovered from the characters by which the torus acts; see `piece_eq_inf`. -/ +lemma GaugeWeight.coord_injective : Function.Injective GaugeWeight.coord := by + rintro ⟨a, b, c, e⟩ ⟨a', b', c', e'⟩ h + have h0 := congrFun h 0 + have h1 := congrFun h 1 + have h2 := congrFun h 2 + have h3 := congrFun h 3 + simp only [GaugeWeight.coord_zero, GaugeWeight.coord_one, GaugeWeight.coord_two, + GaugeWeight.coord_three] at h0 h1 h2 h3 + subst h0 + subst h1 + subst h2 + subst h3 + rfl + +/-! +## C. Gauge weight decompositions + +A gauge weight decomposition is the weight-space decomposition of a representation, with two +differences. It is recorded rather than derived, since the submodules of interest are spans of +explicitly given operators whose charges are read off directly, and it is required only to +cover `V`. Independence of the pieces is not part of the data, because it is automatic, as +section F shows. + +Multiplicativity of the representation is named by `IsMulRep` and stored in the `rep_mul` +field, so that a decomposition of a product can be assembled from decompositions of the factors +with no further input. `copy` moves a decomposition across an equality of submodules, needed +because a submodule arising in practice is usually only propositionally the one for which a +decomposition was recorded. +-/ + +variable {B : Type*} [Ring B] [Algebra ℂ B] + +/-- **A representation acts by algebra maps**, respecting multiplication. This is the + hypothesis under which charges are additive. -/ +abbrev IsMulRep (rep : Representation ℂ GaugeGroupI B) : Prop := + ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y + +/-- A representation that respects multiplication respects the unit, since `g` is invertible + and so `rep g 1` is cancellable. -/ +lemma IsMulRep.map_one {rep : Representation ℂ GaugeGroupI B} (hmul : IsMulRep rep) + (g : GaugeGroupI) : rep g 1 = 1 := by + have h1 := hmul g 1 (rep g⁻¹ 1) + rw [one_mul, rep.self_inv_apply, mul_one] at h1 + exact h1.symm + +/-- A **gauge weight decomposition** of a submodule `V`, a finitely supported family of + subspaces of pure gauge weight whose supremum is `V`. Purity is recorded against the four + commuting torus generators simultaneously. -/ +class GaugeWeightDecomposition (rep : Representation ℂ GaugeGroupI B) + (V : Submodule ℂ B) where + /-- The piece of gauge weight `w`. -/ + piece : GaugeWeight → Submodule ℂ B + /-- The finite set of gauge weights that occur. -/ + supp : Finset GaugeWeight + /-- Gauge transformations act by algebra maps. -/ + rep_mul : IsMulRep rep + /-- Each piece is of pure gauge weight, as seen by all four torus generators. -/ + piece_le : ∀ w, ∀ x, x ∈ piece w → ∀ i, + rep (gaugeTorusGen i) x = ((expI : ℂ) ^ w.coord i) • x + /-- Only the gauge weights in `supp` occur. -/ + piece_eq_bot : ∀ w ∉ supp, piece w = ⊥ + /-- The pieces exhaust `V`. -/ + iSup_piece : (⨆ w, piece w) = V + +namespace GaugeWeightDecomposition + +variable {rep : Representation ℂ GaugeGroupI B} {V V' : Submodule ℂ B} + +/-- The weight-`w` piece lies in the eigenspace of the `i`-th torus generator at the + eigenvalue `(exp i) ^ (w.coord i)`. This is `piece_le` phrased as an inequality of + submodules. -/ +lemma piece_le_eigenspace (d : GaugeWeightDecomposition rep V) (w : GaugeWeight) (i : Fin 4) : + d.piece w ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) ((expI : ℂ) ^ w.coord i) := + fun _ hy => Module.End.mem_eigenspace_iff.mpr (d.piece_le w _ hy i) + +/-- A weight outside the support has vanishing piece. This is the `piece_eq_bot` field, in + the form a `simp` set can use to discard the absent weights of a computed product. -/ +lemma piece_eq_zero_of_not_mem_supp (d : GaugeWeightDecomposition rep V) (w : GaugeWeight) + (hw : w ∉ d.supp) : d.piece w = ⊥ := d.piece_eq_bot w hw + +/-- Transport a decomposition along an equality of submodules. -/ +@[implicit_reducible] +def copy (d : GaugeWeightDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) : + GaugeWeightDecomposition rep W where + piece := d.piece + supp := d.supp + rep_mul := d.rep_mul + piece_le := d.piece_le + piece_eq_bot := d.piece_eq_bot + iSup_piece := by rw [d.iSup_piece, hW] + +@[simp] +lemma copy_piece (d : GaugeWeightDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) : + (copy d W hW).piece = d.piece := rfl + +/-! +## D. Joins + +If `V` and `V'` are decomposed then so is their join `V ⊔ V'`, one weight at a time. Its +weight-`w` piece is the join of the two weight-`w` pieces, and its support is the union of the +supports. A vector of the join need not have definite charge, but it is a sum of vectors that +do, which is all a decomposition claims. + +The binary case `sup`, the empty case `bot`, a finite indexed family `iSup` and a join over a +proposition `iSupProp` are all the same construction. Multiplicativity of `rep` is recovered +from a summand where there is one and supplied as an argument where there is not, since `bot` +decomposes the zero submodule and the indexed forms may range over an empty family. +-/ + +/-- The join of two gauge weight decompositions, decomposing `V ⊔ V'`. Pieces and supports + combine one weight at a time. -/ +@[implicit_reducible] +noncomputable instance sup [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep V'] : GaugeWeightDecomposition rep (V ⊔ V') where + piece w := d.piece w ⊔ d'.piece w + supp := d.supp ∪ d'.supp + rep_mul := d.rep_mul + piece_le w x hx i := + Module.End.mem_eigenspace_iff.mp + (sup_le (d.piece_le_eigenspace w i) (d'.piece_le_eigenspace w i) hx) + piece_eq_bot w hw := by + rw [Finset.mem_union, not_or] at hw + rw [d.piece_eq_bot w hw.1, d'.piece_eq_bot w hw.2, bot_sup_eq] + iSup_piece := by + rw [iSup_sup_eq, d.iSup_piece, d'.iSup_piece] + +@[simp] +lemma sup_piece [GaugeWeightDecomposition rep V] [GaugeWeightDecomposition rep V'] + (w : GaugeWeight) : piece rep (V ⊔ V') w = piece rep V w ⊔ piece rep V' w := rfl + +/-- The zero submodule carries the empty decomposition. -/ +@[implicit_reducible] +def bot (hmul : IsMulRep rep) : + GaugeWeightDecomposition rep (⊥ : Submodule ℂ B) where + piece _ := ⊥ + supp := ∅ + rep_mul := hmul + piece_le w x hx i := by + rw [Submodule.mem_bot] at hx + subst hx + simp + piece_eq_bot _ _ := rfl + iSup_piece := by simp + +@[simp] +lemma bot_piece (hmul : IsMulRep rep) + (w : GaugeWeight) : (bot hmul).piece w = ⊥ := rfl + +@[simp] +lemma bot_supp (hmul : IsMulRep rep) : + (bot hmul).supp = ∅ := rfl + +/-- **An indexed join of decompositions.** A family of decompositions indexed by a finite type + decomposes the join, its pieces joined and its supports united one weight at a time. This is + the arbitrary-arity form of `sup`. -/ +@[implicit_reducible] +noncomputable def iSup {ι : Type*} [Fintype ι] {V : ι → Submodule ℂ B} + (hmul : IsMulRep rep) + (d : (a : ι) → GaugeWeightDecomposition rep (V a)) : + GaugeWeightDecomposition rep (⨆ a, V a) where + piece w := ⨆ a, (d a).piece w + supp := Finset.univ.biUnion fun a => (d a).supp + rep_mul := hmul + piece_le w x hx i := + Module.End.mem_eigenspace_iff.mp + (iSup_le (fun a => (d a).piece_le_eigenspace w i) hx) + piece_eq_bot w hw := by + simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, not_exists] at hw + exact le_antisymm (iSup_le fun a => le_of_eq ((d a).piece_eq_bot w (hw a))) bot_le + iSup_piece := by + rw [iSup_comm] + exact iSup_congr fun a => (d a).iSup_piece + +@[simp] +lemma piece_iSup {ι : Type*} [Fintype ι] {V : ι → Submodule ℂ B} + (hmul : IsMulRep rep) + (d : (a : ι) → GaugeWeightDecomposition rep (V a)) (w : GaugeWeight) : + (iSup hmul d).piece w = ⨆ a, (d a).piece w := rfl + +/-- The support of an indexed join is the union of the supports. -/ +lemma iSup_supp {ι : Type*} [Fintype ι] {V : ι → Submodule ℂ B} + (hmul : IsMulRep rep) + (d : (a : ι) → GaugeWeightDecomposition rep (V a)) : + (iSup hmul d).supp = Finset.univ.biUnion fun a => (d a).supp := rfl + +/-- **A join over a proposition.** `⨆ _ : p, V` is `V` when `p` holds and `⊥` otherwise, so + it is decomposed by the given decomposition or by `bot`. The argument is a function of the + proof, so the decomposition of `V` may itself depend on `p`. -/ +@[implicit_reducible] +noncomputable def iSupProp {p : Prop} [Decidable p] + (hmul : IsMulRep rep) + (d : p → GaugeWeightDecomposition rep V) : + GaugeWeightDecomposition rep (⨆ _ : p, V) := + if hp : p then copy (d hp) _ (iSup_pos hp) else copy (bot hmul) _ (iSup_neg hp) + +/-! +## E. Products + +Charges add when operators are multiplied, and this section is where we prove this fact. +If the torus acts on `x` by the character of `w₁` and on `y` by the character of `w₂` then, +because `rep` respects multiplication, it acts on `x * y` by the product of the two characters, +which additivity of `GaugeWeight.coord` identifies with the character of `w₁ + w₂`. So the +weight-`w` piece of `V * V'` is spanned by products of pieces whose weights sum to `w`, and the +support of a product is the sumset of the supports. + +The unit and the powers belong here for the same reason. The identity of the algebra is a gauge +singlet and so has weight zero, and `V ^ k` is decomposed by iterating the product from it. + +The defining formula `mul_piece` joins over all pairs of weights in `ℤ⁴ × ℤ⁴`. Only finitely +many weights occur, so one of the two can always be eliminated against a support, and +`mul_piece_eq_sub`, `mul_piece_eq_sub'` and `mul_piece_of_supp` do this against the left +factor, the right factor and a supplied finite set. The resulting finite joins are what make +the weight pieces of an iterated product computable. +-/ + +/-- The product of two gauge weight decompositions, decomposing `V * V'`. -/ +@[implicit_reducible] +noncomputable instance mul [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep V'] : + GaugeWeightDecomposition rep (V * V') where + piece w := ⨆ w₁, ⨆ w₂, ⨆ _ : w₁ + w₂ = w, d.piece w₁ * d'.piece w₂ + supp := d.supp + d'.supp + rep_mul := d.rep_mul + piece_le w x hx i := by + have key : (⨆ w₁, ⨆ w₂, ⨆ _ : w₁ + w₂ = w, d.piece w₁ * d'.piece w₂) + ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) ((expI : ℂ) ^ w.coord i) := by + refine iSup_le fun w₁ => iSup_le fun w₂ => iSup_le fun hw => ?_ + refine Submodule.mul_le.mpr fun m hm n hn => ?_ + refine Module.End.mem_eigenspace_iff.mpr ?_ + rw [d.rep_mul, d.piece_le w₁ m hm i, d'.piece_le w₂ n hn i, smul_mul_smul_comm, + ← zpow_add₀ expI_ne_zero, ← GaugeWeight.coord_add, hw] + exact Module.End.mem_eigenspace_iff.mp (key hx) + piece_eq_bot w hw := by + refine le_antisymm (iSup_le fun w₁ => iSup_le fun w₂ => iSup_le fun hsum => ?_) bot_le + by_cases h1 : w₁ ∈ d.supp + · by_cases h2 : w₂ ∈ d'.supp + · exact absurd (hsum ▸ Finset.add_mem_add h1 h2) hw + · rw [d'.piece_eq_bot w₂ h2, Submodule.mul_bot] + · rw [d.piece_eq_bot w₁ h1, Submodule.bot_mul] + iSup_piece := by + refine le_antisymm (iSup_le fun w => iSup_le fun w₁ => iSup_le fun w₂ => + iSup_le fun _ => ?_) ?_ + · exact mul_le_mul' ((le_iSup d.piece w₁).trans d.iSup_piece.le) + ((le_iSup d'.piece w₂).trans d'.iSup_piece.le) + · have hV : (⨆ w₁, d.piece w₁) * (⨆ w₂, d'.piece w₂) = V * V' := by + rw [d.iSup_piece, d'.iSup_piece] + rw [← hV, Submodule.iSup_mul] + refine iSup_le fun w₁ => ?_ + rw [Submodule.mul_iSup] + refine iSup_le fun w₂ => ?_ + exact le_iSup_of_le (w₁ + w₂) + (le_iSup_of_le w₁ (le_iSup_of_le w₂ (le_iSup_of_le rfl le_rfl))) + +/-- The support of a product is the pointwise sum of the supports. -/ +lemma mul_supp [GaugeWeightDecomposition rep V] [GaugeWeightDecomposition rep V'] : + supp rep (V * V') = supp rep V + supp rep V' := rfl + +/-- **Weights add under multiplication.** The weight-`w` piece of a product is spanned by the + products of pieces whose weights sum to `w`. -/ +lemma mul_piece [GaugeWeightDecomposition rep V] [GaugeWeightDecomposition rep V'] + (w : GaugeWeight) : + piece rep (V * V') w + = ⨆ w₁, ⨆ w₂, ⨆ _ : w₁ + w₂ = w, piece rep V w₁ * piece rep V' w₂ := rfl + +/-- The product formula with the second weight eliminated against the support of the left + factor, the right factor being read at the complement `w - w₁`. -/ +lemma mul_piece_eq_sub [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep V'] (w : GaugeWeight) : + piece rep (V * V') w = ⨆ w₁ ∈ supp rep V, piece rep V w₁ * piece rep V' (w - w₁) := by + rw [mul_piece] + refine le_antisymm (iSup_le fun w₁ => iSup_le fun w₂ => iSup_le fun hw => ?_) ?_ + · by_cases h1 : w₁ ∈ d.supp + · refine le_iSup₂_of_le w₁ h1 ?_ + rw [eq_sub_of_add_eq' hw] + · rw [d.piece_eq_bot w₁ h1, Submodule.bot_mul] + exact bot_le + · exact iSup₂_le fun w₁ _ => + le_iSup_of_le w₁ (le_iSup_of_le (w - w₁) (le_iSup_of_le (add_sub_cancel w₁ w) le_rfl)) + +/-- The mirror of `mul_piece_eq_sub`, joining over the weights of the right factor. -/ +lemma mul_piece_eq_sub' [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep V'] (w : GaugeWeight) : + piece rep (V * V') w = ⨆ w₂ ∈ supp rep V', piece rep V (w - w₂) * piece rep V' w₂ := by + rw [mul_piece] + refine le_antisymm (iSup_le fun w₁ => iSup_le fun w₂ => iSup_le fun hw => ?_) ?_ + · by_cases h2 : w₂ ∈ d'.supp + · refine le_iSup₂_of_le w₂ h2 ?_ + rw [eq_sub_of_add_eq hw] + · rw [d'.piece_eq_bot w₂ h2, Submodule.mul_bot] + exact bot_le + · exact iSup₂_le fun w₂ _ => + le_iSup_of_le (w - w₂) (le_iSup_of_le w₂ (le_iSup_of_le (sub_add_cancel w w₂) le_rfl)) + +/-- The decomposition of the unit submodule, concentrated at weight zero. -/ +@[implicit_reducible] +noncomputable def one (hmul : IsMulRep rep) : + GaugeWeightDecomposition rep (1 : Submodule ℂ B) where + piece w := if w = 0 then 1 else ⊥ + supp := {0} + rep_mul := hmul + piece_le := by + intro w x hx i + rcases eq_or_ne w 0 with rfl | hw + · rw [if_pos rfl, Submodule.one_eq_span, Submodule.mem_span_singleton] at hx + obtain ⟨c, rfl⟩ := hx + rw [map_smul, hmul.map_one, GaugeWeight.zero_coord, zpow_zero, one_smul] + · rw [if_neg hw, Submodule.mem_bot] at hx + subst hx + simp + piece_eq_bot w hw := by rw [if_neg (by simpa using hw)] + iSup_piece := by + refine le_antisymm (iSup_le fun w => ?_) (le_iSup_of_le 0 (le_of_eq (if_pos rfl).symm)) + by_cases hw : w = 0 + · rw [if_pos hw] + · rw [if_neg hw] + exact bot_le + +@[simp] +lemma one_piece (hmul : IsMulRep rep) + (w : GaugeWeight) : + (one (B := B) (rep := rep) hmul).piece w = if w = 0 then 1 else ⊥ := rfl + +/-- When the right factor vanishes off a finite set `S` of weights, the weight-`w` piece of a + product collapses to a join over `S`, pairing `w - v` against `v`. -/ +lemma mul_piece_of_supp [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep V'] (S : Finset GaugeWeight) + (hS : ∀ v ∉ S, piece rep V' v = ⊥) (w : GaugeWeight) : + piece rep (V * V') w = ⨆ v ∈ S, piece rep V (w - v) * piece rep V' v := by + rw [mul_piece] + refine le_antisymm (iSup_le fun w₁ => iSup_le fun w₂ => iSup_le fun hw => ?_) ?_ + · by_cases hv : w₂ ∈ S + · refine le_iSup₂_of_le w₂ hv ?_ + rw [eq_sub_of_add_eq hw] + · rw [hS w₂ hv, Submodule.mul_bot] + exact bot_le + · exact iSup₂_le fun v _ => + le_iSup_of_le (w - v) (le_iSup_of_le v (le_iSup_of_le (sub_add_cancel w v) le_rfl)) + +/-- Powers of a decomposed submodule. Gauge weights add, so `V ^ k` inherits a decomposition + by iterating `mul` from `one`. -/ +@[implicit_reducible] +noncomputable instance pow [d : GaugeWeightDecomposition rep V] : + (k : ℕ) → GaugeWeightDecomposition rep (V ^ k) + | 0 => copy (one d.rep_mul) _ (pow_zero V) + | (k + 1) => copy (mul (d := pow (d := d) k) (d' := d)) _ (pow_succ V k) + +@[simp] +lemma pow_zero_piece [d : GaugeWeightDecomposition rep V] (w : GaugeWeight) : + (pow (d := d) 0).piece w = if w = 0 then 1 else ⊥ := rfl + +/-- One step of the power decomposition. Since `V ^ (k + 1)` is `V ^ k` times `V`, its pieces + are given by the product formula against the pieces of `V`. -/ +@[simp] +lemma pow_succ_piece [d : GaugeWeightDecomposition rep V] (k : ℕ) (w : GaugeWeight) : + (pow (d := d) (k + 1)).piece w + = ⨆ w₁, ⨆ w₂, ⨆ _ : w₁ + w₂ = w, (pow (d := d) k).piece w₁ * piece rep V w₂ := rfl + +/-- The `mul_piece_of_supp` collapse applied to a power, so that only the weights in `S` + contribute at each step. -/ +lemma pow_succ_piece_of_supp [d : GaugeWeightDecomposition rep V] (S : Finset GaugeWeight) + (hS : ∀ v ∉ S, piece rep V v = ⊥) (k : ℕ) (w : GaugeWeight) : + (pow (d := d) (k + 1)).piece w + = ⨆ v ∈ S, (pow (d := d) k).piece (w - v) * piece rep V v := + mul_piece_of_supp (d := pow (d := d) k) (d' := d) S hS w + +/-! +## F. Invariants + +A gauge-invariant element is fixed by the torus in particular, so it ought to have zero weight. +Making that an argument requires knowing the pieces are independent. Along one generator this +is immediate, since the pieces sit in eigenspaces of a single operator at the eigenvalues +`(exp i) ^ k`, pairwise distinct because `exp i` is not a root of unity, and eigenspaces at +distinct eigenvalues meet trivially. At rank four no single generator separates the weights, so +the argument is made one generator at a time. + +What this yields is stronger than the statement about invariants. `piece_eq_inf` identifies the +weight-`w` piece with the intersection of `V` and the joint eigenspace of the four generators, +so the pieces depend only on `V` and the representation. + +Zero weight is necessary but not sufficient for invariance. The torus is abelian and sees only +characters, so it cannot distinguish a true singlet from the neutral component of a higher +multiplet. Both `H†H` and `H†σ³H` carry zero weight, and only the first is gauge invariant. So +what passes `mem_zero_of_invariant` must still be checked. `SU2PermDecomposition` narrows the +`SU(2)` factor further, but no grading closes the gap, since a grading sees only the abelian +subgroup generated by the elements it uses. +-/ + +/-- **The one-generator refinement step.** A vector in the span of a family graded along a + single operator, and an eigenvector of that operator at exponent `n`, lies in the span of + just those pieces at exponent `n`. -/ +lemma mem_iSup_of_eigenvector {ι : Type*} {T : Module.End ℂ B} {p : ι → Submodule ℂ B} + {f : ι → ℤ} (hp : ∀ j, p j ≤ Module.End.eigenspace T ((expI : ℂ) ^ f j)) + {x : B} (hx : x ∈ ⨆ j, p j) {n : ℤ} (hT : T x = ((expI : ℂ) ^ n) • x) : + x ∈ ⨆ j, ⨆ _ : f j = n, p j := by + have hQle : ∀ k : ℤ, (⨆ j, ⨆ _ : f j = k, p j) + ≤ Module.End.eigenspace T ((expI : ℂ) ^ k) := + fun k => iSup₂_le fun j hj => hj ▸ hp j + have hQsup : (⨆ k : ℤ, ⨆ j, ⨆ _ : f j = k, p j) = ⨆ j, p j := by + rw [iSup_comm] + exact iSup_congr fun j => + le_antisymm (iSup₂_le fun _ _ => le_rfl) (le_iSup₂_of_le (f j) rfl le_rfl) + have hdisj : Disjoint (Module.End.eigenspace T ((expI : ℂ) ^ n)) + (⨆ k : ℤ, ⨆ _ : k ≠ n, ⨆ j, ⨆ _ : f j = k, p j) := + (((Module.End.eigenspaces_iSupIndep T).comp expI_zpow_injective) n).mono_right + (iSup₂_mono fun k _ => hQle k) + have key : (⨆ k : ℤ, ⨆ j, ⨆ _ : f j = k, p j) + ⊓ Module.End.eigenspace T ((expI : ℂ) ^ n) ≤ ⨆ j, ⨆ _ : f j = n, p j := by + rw [iSup_split_single (fun k : ℤ => ⨆ j, ⨆ _ : f j = k, p j) n, + sup_inf_assoc_of_le _ (hQle n)] + exact sup_le le_rfl (hdisj.symm.le_bot.trans bot_le) + exact key ⟨hQsup ▸ hx, Module.End.mem_eigenspace_iff.mpr hT⟩ + +/-- **The many-generator refinement.** The same for a finite family of operators. A vector in + the span of the family and an eigenvector of every operator lies in the span of just those + pieces whose exponents match throughout. -/ +lemma mem_iSup_of_forall_eigenvector {ι κ : Type*} [Fintype κ] [DecidableEq κ] + {T : κ → Module.End ℂ B} {p : ι → Submodule ℂ B} {f : ι → κ → ℤ} + (hp : ∀ j k, p j ≤ Module.End.eigenspace (T k) ((expI : ℂ) ^ f j k)) + {x : B} (hx : x ∈ ⨆ j, p j) {n : κ → ℤ} + (hT : ∀ k, T k x = ((expI : ℂ) ^ n k) • x) : + x ∈ ⨆ j, ⨆ _ : f j = n, p j := by + have key : ∀ S : Finset κ, x ∈ ⨆ j, ⨆ _ : ∀ k ∈ S, f j k = n k, p j := by + intro S + induction S using Finset.induction_on with + | empty => simpa using hx + | @insert k S hk ih => + have hstep := mem_iSup_of_eigenvector (T := T k) (f := fun j => f j k) + (p := fun j => ⨆ _ : ∀ k' ∈ S, f j k' = n k', p j) + (fun j => iSup_le fun _ => hp j k) ih (hT k) + have hle : (⨆ j, ⨆ _ : f j k = n k, ⨆ _ : ∀ k' ∈ S, f j k' = n k', p j) + ≤ ⨆ j, ⨆ _ : ∀ k' ∈ insert k S, f j k' = n k', p j := by + refine iSup_le fun j => iSup_le fun h1 => iSup_le fun h2 => + le_iSup_of_le j (le_iSup_of_le ?_ le_rfl) + intro k' hk' + rcases Finset.mem_insert.mp hk' with rfl | hk'S + · exact h1 + · exact h2 k' hk'S + exact hle hstep + have hle : (⨆ j, ⨆ _ : ∀ k ∈ (Finset.univ : Finset κ), f j k = n k, p j) + ≤ ⨆ j, ⨆ _ : f j = n, p j := + iSup_le fun j => iSup_le fun hj => + le_iSup_of_le j (le_iSup_of_le (funext fun k => hj k (Finset.mem_univ k)) le_rfl) + exact hle (key Finset.univ) + +/-- **The pieces are canonical.** The weight-`w` piece is exactly the part of `V` on which the + four torus generators act by the weight-`w` characters. See `piece_congr`. -/ +lemma piece_eq_inf (d : GaugeWeightDecomposition rep V) (w : GaugeWeight) : + d.piece w + = V ⊓ ⨅ i, Module.End.eigenspace (rep (gaugeTorusGen i)) ((expI : ℂ) ^ w.coord i) := by + refine le_antisymm (le_inf ((le_iSup d.piece w).trans (le_of_eq d.iSup_piece)) + (le_iInf fun i => d.piece_le_eigenspace w i)) fun x hx => ?_ + obtain ⟨hxV, hxE⟩ := hx + have hx0 : x ∈ ⨆ w' : GaugeWeight, d.piece w' := by rw [d.iSup_piece]; exact hxV + have hspan : x ∈ ⨆ w' : GaugeWeight, ⨆ _ : w'.coord = w.coord, d.piece w' := + mem_iSup_of_forall_eigenvector (T := fun i => rep (gaugeTorusGen i)) (p := d.piece) + (f := fun w' : GaugeWeight => w'.coord) (n := w.coord) + (fun w' i => d.piece_le_eigenspace w' i) hx0 + (fun i => Module.End.mem_eigenspace_iff.mp (Submodule.mem_iInf _ |>.mp hxE i)) + have hle : (⨆ w' : GaugeWeight, ⨆ _ : w'.coord = w.coord, d.piece w') ≤ d.piece w := + iSup_le fun w' => iSup_le fun hw' => + le_of_eq (congrArg d.piece (GaugeWeight.coord_injective hw')) + exact hle hspan + +/-- **The pieces depend only on the submodule.** Two decompositions of equal submodules have + the same pieces, so a computation of `piece` may be carried along any equality of + submodules. -/ +lemma piece_congr {W : Submodule ℂ B} [d : GaugeWeightDecomposition rep V] + [d' : GaugeWeightDecomposition rep W] (hVW : V = W) (w : GaugeWeight) : + d.piece w = d'.piece w := by + rw [d.piece_eq_inf, d'.piece_eq_inf, hVW] + +/-- **A gauge-invariant element sits in the zero-weight piece.** Only invariance under the + four torus generators is used. The converse is false; see the warning in section F. -/ +lemma mem_zero_of_invariant (d : GaugeWeightDecomposition rep V) {x : B} (hx : x ∈ V) + (hV : ∀ g : GaugeGroupI, rep g x = x) : x ∈ d.piece 0 := by + rw [d.piece_eq_inf] + refine ⟨hx, Submodule.mem_iInf _ |>.mpr fun i => ?_⟩ + rw [Module.End.mem_eigenspace_iff, GaugeWeight.zero_coord, zpow_zero, one_smul] + exact hV _ + +end GaugeWeightDecomposition +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Jet/Basic.lean b/Physlib/Particles/StandardModel/GaugeGroup/Jet/Basic.lean new file mode 100644 index 000000000..7b5b9de6d --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Jet/Basic.lean @@ -0,0 +1,446 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Relativity.DerivAlgebra +public import Mathlib.RingTheory.MvPowerSeries.Basic +public import Mathlib.LinearAlgebra.Matrix.Determinant.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basis +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic +/-! + +# The jet gauge group + +## i. Overview + +For the Standard Model on Minkowski spacetime, +gauge transforms are maps from spacetime to the gauge group `G := SU(3) × SU(2) × U(1)`. + +If one is considering a gauge transformation `g` at a point `x`, its action +on all the fields and their derivatives at `x` is determined by the +value of `g` and all its derivatives at `x`. The collection of all +possible values of `g` and their derivatives at `x` is called the *jet* of `g` at `x`. +These form a group, which we call `JetGaugeGroupI`. + +The group `JetGaugeGroupI` acts on all the fields and their derivatives at `x`, +every gauge transformation `g` has a corresponding element of `JetGaugeGroupI`, +and the action of `g` on the fields and their derivatives at `x` is determined by this element. + +Thus locally it is enough to consider the action of `JetGaugeGroupI` on the fields and +their derivatives at a point, instead of the full set of gauge transformations on spacetime, +which is large and unwieldy. + +## Start at a better overview + +A Lagrangian at a point x is a polynomial in the fields and + finitely many of their derivatives at x — that is the whole of + its input. Symmetries of such an expression can therefore only + ever see fields through that same finite window, and so a + symmetry given by a function g : M → G can only act through the + data g(x), ∂g(x), ∂²g(x), …. Two gauge transformations with the + same Taylor expansion at x are indistinguishable to every + Lagrangian at x: the honest symmetry group is not C^∞(M, G) but + its quotient by that equivalence, the group of jets at x. + + +So we want to work with Taylor expansions rather than functions. +The key observation is that Taylor expansions can be added and +multiplied just like numbers: the coefficients of a product are +given by the familiar sums of binomial coefficients times pairs +of derivatives, which is just the Leibniz rule. This makes them a +ring, which we call JetRing — it plays the same role that ℂ does +for ordinary numbers, only its elements record a value together +with all of its derivatives. + +Now, a group like SU(3), SU(2), or U(1) is defined by equations + in matrix entries — U*U = 1, det U = 1 — and nothing in those + equations demands that the entries be complex numbers. They make + sense whenever the entries can be added, multiplied, and + conjugated. In particular, they make sense for matrices whose + entries are Taylor expansions. Writing down the Standard Model + gauge group with entries in JetRing instead of ℂ gives + JetGaugeGroupI, and unwinding the definitions shows this is + precisely the group of Taylor expansions of gauge + transformations: an element is a g(x) together with all its + derivatives, constrained to be unitary order by order. + +The payoff is that the derivative bookkeeping disappears into th + ring multiplication. Products, inverses, and the adjoint action + of jets are just the group operations of JetGaugeGroupI, so + facts like "the jet of the inverse is the inverse of the jet" + hold for free instead of needing a separate check at each + order. We use infinite Taylor expansions rather than truncating + at some order k, so that a single group acts on Lagrangians of + every derivative order at once. The resulting group is blind to + everything global — topology, winding, large gauge + transformations — which is exactly right, since so is a + Lagrangian at a point. + + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MvPowerSeries JetRing +open scoped Nat + +/-! + +## B. The jet gauge group + +The ring `JetRing` of formal power series in the spacetime coordinates, in which +jets of fields and of gauge transformations are valued, is defined in +`Physlib.Relativity.DerivAlgebra`, together with the algebra of derivative +symbols `DerivAlgebraComplex` and the action `DerivAlgebraComplex.jetRingAction` +of the jet ring on it. + +-/ + +/-- The group of formal infinite-order jets, at a spacetime point, of local gauge + transformations of the Standard Model: the `R`-points of the gauge group for `R` + the ring `JetRing` of formal power series in the spacetime coordinates. + + Since gauge transformations multiply pointwise, jets multiply as power series and + the group structure is that of the matrix groups over `JetRing`. The unitarity and + determinant constraints hold as power-series identities, i.e. at every jet order. + + Evaluation at the base point recovers `GaugeGroupI`; see `JetGaugeGroupI.eval`. -/ +abbrev JetGaugeGroupI : Type := + specialUnitaryGroup (Fin 3) JetRing × specialUnitaryGroup (Fin 2) JetRing × + unitary JetRing + +namespace JetGaugeGroupI + + +/-- The underlying matrix value of an element of `JetGaugeGroupI`. -/ +def toVal (U : JetGaugeGroupI) : Matrix (Fin 3) (Fin 3) JetRing × Matrix (Fin 2) (Fin 2) JetRing × JetRing := + (U.1.1, U.2.1.1, U.2.2.1) + +/-! + +## C. Evaluation at the base point + +The constant coefficient of a power series is its value at the base point of the +jet. Applied entrywise it sends jets of gauge transformations to their zeroth-order +parts, giving a group homomorphism `JetGaugeGroupI →* GaugeGroupI`. + +-/ + +/-- Entrywise evaluation at the base point commutes with the conjugate transpose. -/ +lemma mapMatrix_constantCoeff_star {n : Type} [Fintype n] [DecidableEq n] + (A : Matrix n n JetRing) : + (constantCoeff : JetRing →+* ℂ).mapMatrix (star A) = + star ((constantCoeff : JetRing →+* ℂ).mapMatrix A) := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.star_apply] + +/-- Evaluation of a jet of a special-unitary gauge transformation at the base point: + the entrywise constant coefficient. -/ +noncomputable def evalSU (n : Type) [Fintype n] [DecidableEq n] : + specialUnitaryGroup n JetRing →* specialUnitaryGroup n ℂ where + toFun U := ⟨(constantCoeff : JetRing →+* ℂ).mapMatrix U.1, by + obtain ⟨h1, h2⟩ := mem_specialUnitaryGroup_iff.mp U.2 + rw [mem_specialUnitaryGroup_iff] + constructor + · rw [mem_unitaryGroup_iff] at h1 ⊢ + rw [show star ((constantCoeff : JetRing →+* ℂ).mapMatrix U.1) = + (constantCoeff : JetRing →+* ℂ).mapMatrix (star U.1) from + (mapMatrix_constantCoeff_star U.1).symm, ← map_mul, h1, map_one] + · rw [← RingHom.map_det, h2, map_one]⟩ + map_one' := Subtype.ext (map_one ((constantCoeff : JetRing →+* ℂ).mapMatrix)) + map_mul' U V := Subtype.ext (map_mul ((constantCoeff : JetRing →+* ℂ).mapMatrix) U.1 V.1) + +/-- Evaluation of a jet of a `U(1)` gauge transformation at the base point: the + constant coefficient. -/ +noncomputable def evalU1 : unitary JetRing →* unitary ℂ where + toFun u := ⟨constantCoeff u.1, by + obtain ⟨h1, h2⟩ := Unitary.mem_iff.mp u.2 + exact Unitary.mem_iff.mpr + ⟨by rw [← constantCoeff_star, ← map_mul, h1, map_one], + by rw [← constantCoeff_star, ← map_mul, h2, map_one]⟩⟩ + map_one' := Subtype.ext (map_one _) + map_mul' u v := Subtype.ext (map_mul _ u.1 v.1) + +/-- Evaluation of a jet of a gauge transformation at the base point, projecting the + jet gauge group onto the gauge group `GaugeGroupI` by taking zeroth-order parts on + each factor. -/ +noncomputable def eval : JetGaugeGroupI →* GaugeGroupI := + (evalSU (Fin 3)).prodMap ((evalSU (Fin 2)).prodMap evalU1) + + +/-! + +## The derivative + +We define the derivative of an element of `JetGaugeGroupI` as a product of matrices, +and give some properties of it related to the Maurer–Cartan form. + +-/ + +/-- The derivative of an element of `JetGaugeGroupI` returning + a product of matrices. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + Matrix (Fin 3) (Fin 3) JetRing × Matrix (Fin 2) (Fin 2) JetRing × JetRing := + (U.1.1.map (pderiv ℂ μ), U.2.1.1.map (pderiv ℂ μ), pderiv ℂ μ U.2.2.1) + + +lemma deriv_mul (μ : Fin 1 ⊕ Fin 3) (U V : JetGaugeGroupI) : + deriv μ (U * V) = deriv μ U * V.toVal + U.toVal * deriv μ V := by + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show (U.1.1 * V.1.1).map (pderiv ℂ μ) = + U.1.1.map (pderiv ℂ μ) * V.1.1 + U.1.1 * V.1.1.map (pderiv ℂ μ) + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + · show (U.2.1.1 * V.2.1.1).map (pderiv ℂ μ) = + U.2.1.1.map (pderiv ℂ μ) * V.2.1.1 + U.2.1.1 * V.2.1.1.map (pderiv ℂ μ) + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + · show pderiv ℂ μ (U.2.2.1 * V.2.2.1) = + pderiv ℂ μ U.2.2.1 * V.2.2.1 + U.2.2.1 * pderiv ℂ μ V.2.2.1 + rw [Derivation.leibniz] + simp only [smul_eq_mul] + ring + +@[simp] +lemma deriv_one (μ : Fin 1 ⊕ Fin 3) : deriv μ (1 : JetGaugeGroupI) = 0 := by + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show (1 : Matrix (Fin 3) (Fin 3) JetRing).map (pderiv ℂ μ) = 0 + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ μ)] + · show (1 : Matrix (Fin 2) (Fin 2) JetRing).map (pderiv ℂ μ) = 0 + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ μ)] + · show pderiv ℂ μ (1 : JetRing) = 0 + exact pderiv_one + +lemma star_deriv (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + star (deriv μ U) = deriv μ (star U) := by + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show star (U.1.1.map (pderiv ℂ μ)) = (star U.1.1).map (pderiv ℂ μ) + ext i j : 1 + simp only [Matrix.star_apply, Matrix.map_apply] + exact (JetRing.pderiv_star μ (U.1.1 j i)).symm + · show star (U.2.1.1.map (pderiv ℂ μ)) = (star U.2.1.1).map (pderiv ℂ μ) + ext i j : 1 + simp only [Matrix.star_apply, Matrix.map_apply] + exact (JetRing.pderiv_star μ (U.2.1.1 j i)).symm + · show star (pderiv ℂ μ U.2.2.1) = pderiv ℂ μ (star U.2.2.1) + exact (JetRing.pderiv_star μ U.2.2.1).symm + +lemma deriv_mul_inv_toVal_SU3_traceless (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + (Complex.I • (deriv μ U * (U⁻¹).toVal)).1.trace = 0 := by + set A : Matrix (Fin 3) (Fin 3) JetRing := U.1.1 with hA + have hU : A * star A = 1 := by + have h := (mem_specialUnitaryGroup_iff.mp U.1.2).1 + rwa [mem_unitaryGroup_iff] at h + have hdet : A.det = 1 := (mem_specialUnitaryGroup_iff.mp U.1.2).2 + have hadj : star A = A.adjugate := by + have h1 : star A * A = 1 := mul_eq_one_comm.mp hU + calc star A = star A * (A * A.adjugate) := by + rw [Matrix.mul_adjugate, hdet, one_smul, mul_one] + _ = star A * A * A.adjugate := by rw [mul_assoc] + _ = A.adjugate := by rw [h1, one_mul] + have jacobi : (A.map (pderiv ℂ μ) * A.adjugate).trace = pderiv ℂ μ A.det := by + rw [Matrix.det_fin_three] + simp only [Matrix.trace_fin_three, Matrix.mul_apply, Fin.sum_univ_three, + Matrix.map_apply, Matrix.adjugate_fin_three, Matrix.of_apply, Matrix.cons_val', + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, Matrix.head_cons, + Matrix.tail_cons, Matrix.head_fin_const, Matrix.empty_val', Matrix.cons_val_fin_one, + map_sub, map_add, Derivation.leibniz, smul_eq_mul] + ring + rw [show (Complex.I • (deriv μ U * (U⁻¹).toVal)).1 = + Complex.I • (A.map (pderiv ℂ μ) * star A) from rfl, + Matrix.trace_smul, hadj, jacobi, hdet, pderiv_one, smul_zero] + +lemma deriv_mul_inv_toVal_SU2_traceless (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1.trace = 0 := by + set A : Matrix (Fin 2) (Fin 2) JetRing := U.2.1.1 with hA + have hU : A * star A = 1 := by + have h := (mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rwa [mem_unitaryGroup_iff] at h + have hdet : A.det = 1 := (mem_specialUnitaryGroup_iff.mp U.2.1.2).2 + have hadj : star A = A.adjugate := by + have h1 : star A * A = 1 := mul_eq_one_comm.mp hU + calc star A = star A * (A * A.adjugate) := by + rw [Matrix.mul_adjugate, hdet, one_smul, mul_one] + _ = star A * A * A.adjugate := by rw [mul_assoc] + _ = A.adjugate := by rw [h1, one_mul] + have jacobi : (A.map (pderiv ℂ μ) * A.adjugate).trace = pderiv ℂ μ A.det := by + rw [Matrix.det_fin_two] + simp only [adjugate_fin_two, trace_fin_two, Matrix.mul_apply, map_apply, of_apply, cons_val', + cons_val_zero, empty_val', cons_val_fin_one, Fin.sum_univ_two, cons_val_one, map_sub, + Derivation.leibniz, smul_eq_mul] + ring + rw [show (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1 = + Complex.I • (A.map (pderiv ℂ μ) * star A) from rfl, + Matrix.trace_smul, hadj, jacobi, hdet, pderiv_one, smul_zero] + +lemma star_deriv_mul_inv_toVal_SU3 (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + star ((Complex.I • (deriv μ U * (U⁻¹).toVal)).1) = + (Complex.I • (deriv μ U * (U⁻¹).toVal)).1 := by + set A : Matrix (Fin 3) (Fin 3) JetRing := U.1.1 with hA + -- differentiate the unitarity relation `U U⁻¹ = 1` with the Leibniz rule `deriv_mul` + have h := deriv_mul μ U U⁻¹ + rw [mul_inv_cancel, deriv_one] at h + have hq : A * ((star A).map (pderiv ℂ μ)) = -(A.map (pderiv ℂ μ) * star A) := + congrArg (fun p => p.1) (eq_neg_of_add_eq_zero_right h.symm) + have hstarmap : star (A.map (pderiv ℂ μ)) = (star A).map (pderiv ℂ μ) := + congrArg (fun p => p.1) (star_deriv μ U) + -- rewrite the `ℂ`-scalar `i` as the constant series `C i`, acting through `JetRing` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).1 = + (MvPowerSeries.C Complex.I : JetRing) • (A.map (pderiv ℂ μ) * star A) := by + rw [show (Complex.I • (deriv μ U * (U⁻¹).toVal)).1 = + Complex.I • (A.map (pderiv ℂ μ) * star A) from rfl] + ext i j + simp only [Matrix.smul_apply, smul_eq_mul, Algebra.smul_def, + MvPowerSeries.algebraMap_apply] + simp + -- the star flips `i` to `-i` and the differentiated unitarity flips the product back + rw [hCs, star_smul, star_mul, star_star, hstarmap, hq, JetRing.star_C, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_smul, smul_neg, neg_neg] + +lemma star_deriv_mul_inv_toVal_SU2 (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + star ((Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1) = + (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1 := by + set A : Matrix (Fin 2) (Fin 2) JetRing := U.2.1.1 with hA + -- differentiate the unitarity relation `U U⁻¹ = 1` with the Leibniz rule `deriv_mul` + have h := deriv_mul μ U U⁻¹ + rw [mul_inv_cancel, deriv_one] at h + have hq : A * ((star A).map (pderiv ℂ μ)) = -(A.map (pderiv ℂ μ) * star A) := + congrArg (fun p => p.2.1) (eq_neg_of_add_eq_zero_right h.symm) + have hstarmap : star (A.map (pderiv ℂ μ)) = (star A).map (pderiv ℂ μ) := + congrArg (fun p => p.2.1) (star_deriv μ U) + -- rewrite the `ℂ`-scalar `i` as the constant series `C i`, acting through `JetRing` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1 = + (MvPowerSeries.C Complex.I : JetRing) • (A.map (pderiv ℂ μ) * star A) := by + rw [show (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.1 = + Complex.I • (A.map (pderiv ℂ μ) * star A) from rfl] + ext i j + simp only [Matrix.smul_apply, smul_eq_mul, Algebra.smul_def, + MvPowerSeries.algebraMap_apply] + simp + -- the star flips `i` to `-i` and the differentiated unitarity flips the product back + rw [hCs, star_smul, star_mul, star_star, hstarmap, hq, JetRing.star_C, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_smul, smul_neg, neg_neg] + +lemma star_deriv_mul_inv_toVal_U1 (μ : Fin 1 ⊕ Fin 3) (U : JetGaugeGroupI) : + star ((Complex.I • (deriv μ U * (U⁻¹).toVal)).2.2) = + (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.2 := by + set u : JetRing := U.2.2.1 with hu' + -- differentiate the unitarity relation `U U⁻¹ = 1` with the Leibniz rule `deriv_mul` + have h := deriv_mul μ U U⁻¹ + rw [mul_inv_cancel, deriv_one] at h + have hq : pderiv ℂ μ (star u) * u = -(pderiv ℂ μ u * star u) := + (mul_comm _ _).trans (congrArg (fun p => p.2.2) (eq_neg_of_add_eq_zero_right h.symm)) + -- rewrite the `ℂ`-scalar `i` as the constant series `C i`, acting through `JetRing` + have hCs : (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.2 = + (MvPowerSeries.C Complex.I : JetRing) * (pderiv ℂ μ u * star u) := by + rw [show (Complex.I • (deriv μ U * (U⁻¹).toVal)).2.2 = + Complex.I • (pderiv ℂ μ u * star u) from rfl, + Algebra.smul_def, MvPowerSeries.algebraMap_apply] + simp + -- the star flips `i` to `-i` and the differentiated unitarity flips the product back + rw [hCs, star_mul', JetRing.star_C, star_mul', star_star, ← JetRing.pderiv_star, hq, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_mul, mul_neg, neg_neg] + + +/-- The iterated formal derivative, in the (unordered) directions given by the + multiset `s`, of the value of a jet gauge transformation, taken entrywise on each + factor. This is the derivative-normalized Taylor coefficient of `U` at `s`, as a jet: + its value at the base point is `∏ (s.count μ)!` times the power-series coefficient + of `U` at the monomial `s`. -/ +noncomputable def iteratedDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI) : + Matrix (Fin 3) (Fin 3) JetRing × Matrix (Fin 2) (Fin 2) JetRing × JetRing := + (U.1.1.map fun f => s.foldl (fun f μ => pderiv ℂ μ f) f, + U.2.1.1.map fun f => s.foldl (fun f μ => pderiv ℂ μ f) f, + s.foldl (fun f μ => pderiv ℂ μ f) U.2.2.1) + +/-! + +## D. Constant jets + +The constant power series embed the gauge group `GaugeGroupI` into the jet gauge +group, as the jets of constant (global) gauge transformations. This is a section of +the evaluation `eval`. + +-/ + +/-- Entrywise inclusion of constants commutes with the conjugate transpose. -/ +lemma mapMatrix_C_star {n : Type} [Fintype n] [DecidableEq n] (A : Matrix n n ℂ) : + (C : ℂ →+* JetRing).mapMatrix (star A) = star ((C : ℂ →+* JetRing).mapMatrix A) := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.star_apply] + +/-- The jet of a constant special-unitary gauge transformation: the entrywise + inclusion of constants. -/ +noncomputable def ofConstantSU (n : Type) [Fintype n] [DecidableEq n] : + specialUnitaryGroup n ℂ →* specialUnitaryGroup n JetRing where + toFun u := ⟨(C : ℂ →+* JetRing).mapMatrix u.1, by + obtain ⟨h1, h2⟩ := mem_specialUnitaryGroup_iff.mp u.2 + rw [mem_specialUnitaryGroup_iff] + constructor + · rw [mem_unitaryGroup_iff] at h1 ⊢ + rw [show star ((C : ℂ →+* JetRing).mapMatrix u.1) = + (C : ℂ →+* JetRing).mapMatrix (star u.1) from (mapMatrix_C_star u.1).symm, + ← map_mul, h1, map_one] + · rw [← RingHom.map_det, h2, map_one]⟩ + map_one' := Subtype.ext (map_one ((C : ℂ →+* JetRing).mapMatrix)) + map_mul' u v := Subtype.ext (map_mul ((C : ℂ →+* JetRing).mapMatrix) u.1 v.1) + +/-- The jet of a constant `U(1)` gauge transformation: the inclusion of constants. -/ +noncomputable def ofConstantU1 : unitary ℂ →* unitary JetRing where + toFun u := ⟨C u.1, by + obtain ⟨h1, h2⟩ := Unitary.mem_iff.mp u.2 + exact Unitary.mem_iff.mpr + ⟨by rw [star_C, ← map_mul, h1, map_one], + by rw [star_C, ← map_mul, h2, map_one]⟩⟩ + map_one' := Subtype.ext (map_one _) + map_mul' u v := Subtype.ext (map_mul _ u.1 v.1) + +/-- The embedding of the gauge group into the jet gauge group as the jets of + constant (global) gauge transformations. -/ +noncomputable def ofConstant : GaugeGroupI →* JetGaugeGroupI := + (ofConstantSU (Fin 3)).prodMap ((ofConstantSU (Fin 2)).prodMap ofConstantU1) + +/-- Evaluating the jet of a constant gauge transformation at the base point recovers + the gauge transformation: `ofConstant` is a section of `eval`. -/ +@[simp] +lemma eval_ofConstant (g : GaugeGroupI) : eval (ofConstant g) = g := by + refine Prod.ext (Subtype.ext ?_) (Prod.ext (Subtype.ext ?_) (Subtype.ext ?_)) + · ext i j + simp [eval, ofConstant, evalSU, ofConstantSU, + RingHom.mapMatrix_apply, Matrix.map_apply] + · ext i j + simp [eval, ofConstant, evalSU, ofConstantSU, + RingHom.mapMatrix_apply, Matrix.map_apply] + · simp [eval, ofConstant, evalU1, ofConstantU1] + +@[simp] +lemma deriv_ofConstant (μ : Fin 1 ⊕ Fin 3) (U₀ : GaugeGroupI) : + deriv μ (JetGaugeGroupI.ofConstant U₀) = 0 := by + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show ((C : ℂ →+* JetRing).mapMatrix U₀.1.1).map (pderiv ℂ μ) = 0 + ext i j : 1 + simp [RingHom.mapMatrix_apply, Matrix.map_apply, pderiv_C] + · show ((C : ℂ →+* JetRing).mapMatrix U₀.2.1.1).map (pderiv ℂ μ) = 0 + ext i j : 1 + simp [RingHom.mapMatrix_apply, Matrix.map_apply, pderiv_C] + · show pderiv ℂ μ (C U₀.2.2.1 : JetRing) = 0 + simp [pderiv_C] + +end JetGaugeGroupI + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/Jet/Truncation.lean b/Physlib/Particles/StandardModel/GaugeGroup/Jet/Truncation.lean new file mode 100644 index 000000000..353aa895e --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/Jet/Truncation.lean @@ -0,0 +1,254 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +/-! +# Truncation of the Jet gauge group + +-/ + +@[expose] public section + +open MvPowerSeries + +namespace StandardModel + +namespace JetGaugeGroupI + +/-- The `n`-th truncation of a jet of a gauge transformation: componentwise, all + Taylor coefficients of total degree greater than `n` are set to zero. + + This is a plain function into the underlying matrix data, not a homomorphism + into `JetGaugeGroupI`: deleting the coefficients above order `n` breaks both + unitarity and multiplicativity at the orders between `n + 1` and `2 n` — the + relations `U U† = 1` and `(U V)_m = ∑ U_p V_q` at those orders depend on the + deleted coefficients. The homomorphic packaging of truncation is the quotient + of `JetGaugeGroupI` by the normal subgroup of jets agreeing with `1` up to + order `n`, not a self-map. -/ +noncomputable def truncation (n : ℕ) (U : JetGaugeGroupI) : + Matrix (Fin 3) (Fin 3) JetRing × Matrix (Fin 2) (Fin 2) JetRing × JetRing := + (U.1.1.map (JetRing.truncation n), U.2.1.1.map (JetRing.truncation n), + JetRing.truncation n U.2.2.1) + +/-- Truncation of the identity jet is the identity value triple. -/ +@[simp] +lemma truncation_one (n : ℕ) : truncation n (1 : JetGaugeGroupI) = 1 := + Prod.ext (Matrix.map_one _ (JetRing.truncation_zero n) (JetRing.truncation_one n)) + (Prod.ext (Matrix.map_one _ (JetRing.truncation_zero n) (JetRing.truncation_one n)) + (JetRing.truncation_one n)) + +/-! + +## The kernel of truncation + +-/ + + +/-- The subgroup of jets agreeing with the identity up to order `n`: the kernel of + the `n`-th truncation. These form the natural descending filtration of + `JetGaugeGroupI` whose quotients are the finite-order jet groups; the `n = 0` + member is the pure jet gauge group. -/ +noncomputable def truncationKer (n : ℕ) : Subgroup JetGaugeGroupI where + carrier := {U | truncation n U = truncation n 1} + one_mem' := rfl + mul_mem' {a b} ha hb := by + have ha3 : a.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.1) ha + have hb3 : b.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.1) hb + have ha2 : a.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.2.1) ha + have hb2 : b.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.2.1) hb + have ha1 : JetRing.truncation n a.2.2.1 = JetRing.truncation n 1 := + congrArg (fun p => p.2.2) ha + have hb1 : JetRing.truncation n b.2.2.1 = JetRing.truncation n 1 := + congrArg (fun p => p.2.2) hb + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show (a.1.1 * b.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_mul_congr ha3 hb3, one_mul] + · show (a.2.1.1 * b.2.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_mul_congr ha2 hb2, one_mul] + · show JetRing.truncation n (a.2.2.1 * b.2.2.1) = JetRing.truncation n 1 + rw [JetRing.truncation_mul_congr ha1 hb1, one_mul] + inv_mem' {a} ha := by + have ha3 : a.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.1) ha + have ha2 : a.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.2.1) ha + have ha1 : JetRing.truncation n a.2.2.1 = JetRing.truncation n 1 := + congrArg (fun p => p.2.2) ha + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show (star a.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_star, ha3, ← JetRing.matrix_truncation_star, star_one] + · show (star a.2.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_star, ha2, ← JetRing.matrix_truncation_star, star_one] + · show JetRing.truncation n (star a.2.2.1) = JetRing.truncation n 1 + rw [JetRing.truncation_star, ha1, ← JetRing.truncation_star, star_one] + +lemma mem_truncationKer_iff {n : ℕ} {U : JetGaugeGroupI} : + U ∈ truncationKer n ↔ truncation n U = truncation n 1 := Iff.rfl + +/-- Membership in the kernel of truncation, stated against the identity value. -/ +lemma mem_truncationKer_iff_eq_one {n : ℕ} {U : JetGaugeGroupI} : + U ∈ truncationKer n ↔ truncation n U = 1 := by + rw [mem_truncationKer_iff, truncation_one] + +/-- The kernel of truncation is normal: conjugating a jet that agrees with `1` up + to order `n` leaves it agreeing with `1` up to order `n`, since to that order + the conjugation collapses to `g * g⁻¹ = 1` by unitarity. -/ +instance truncationKer_normal (n : ℕ) : (truncationKer n).Normal where + conj_mem a ha g := by + have ha3 : a.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.1) ha + have ha2 : a.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) := + congrArg (fun p => p.2.1) ha + have ha1 : JetRing.truncation n a.2.2.1 = JetRing.truncation n 1 := + congrArg (fun p => p.2.2) ha + have hg3 : g.1.1 * star g.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp g.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hg2 : g.2.1.1 * star g.2.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp g.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hg1 : g.2.2.1 * star g.2.2.1 = 1 := (Unitary.mem_iff.mp g.2.2.2).2 + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show ((g.1.1 * a.1.1) * star g.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_mul_congr + (JetRing.matrix_truncation_mul_congr rfl ha3) rfl, mul_one, hg3] + · show ((g.2.1.1 * a.2.1.1) * star g.2.1.1).map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) + rw [JetRing.matrix_truncation_mul_congr + (JetRing.matrix_truncation_mul_congr rfl ha2) rfl, mul_one, hg2] + · show JetRing.truncation n ((g.2.2.1 * a.2.2.1) * star g.2.2.1) = + JetRing.truncation n 1 + rw [JetRing.truncation_mul_congr (JetRing.truncation_mul_congr rfl ha1) rfl, + mul_one, hg1] + +/-! + +## The zeroth truncation kernel: the pure jet gauge group + +The kernel of the zeroth truncation consists of the jets whose value at the base +point is the identity — what was previously called the pure jet gauge group. + +-/ + +/-- Membership in the zeroth truncation kernel is having identity value at the + base point. -/ +lemma mem_truncationKer_zero_iff {U : JetGaugeGroupI} : + U ∈ truncationKer 0 ↔ U.eval = 1 := by + rw [mem_truncationKer_iff] + constructor + · intro h + refine Prod.ext (Subtype.ext ?_) (Prod.ext (Subtype.ext ?_) (Subtype.ext ?_)) + · ext i j : 1 + have h3 := congrArg (fun p => (p.1 : Matrix (Fin 3) (Fin 3) JetRing) i j) h + simpa [eval, evalSU, RingHom.mapMatrix_apply, Matrix.map_apply, + Matrix.one_apply, apply_ite constantCoeff] using + JetRing.truncation_zero_eq_iff.mp h3 + · ext i j : 1 + have h2 := congrArg (fun p => (p.2.1 : Matrix (Fin 2) (Fin 2) JetRing) i j) h + simpa [eval, evalSU, RingHom.mapMatrix_apply, Matrix.map_apply, + Matrix.one_apply, apply_ite constantCoeff] using + JetRing.truncation_zero_eq_iff.mp h2 + · simpa [eval, evalU1] using + JetRing.truncation_zero_eq_iff.mp (congrArg (fun p => (p.2.2 : JetRing)) h) + · intro h + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show U.1.1.map (JetRing.truncation 0) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation 0) + ext i j : 1 + refine JetRing.truncation_zero_eq_iff.mpr ?_ + have h3 := congrArg (fun p => (p.1 : Matrix (Fin 3) (Fin 3) ℂ) i j) h + simpa [eval, evalSU, RingHom.mapMatrix_apply, Matrix.map_apply, + Matrix.one_apply, apply_ite constantCoeff] using h3 + · show U.2.1.1.map (JetRing.truncation 0) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation 0) + ext i j : 1 + refine JetRing.truncation_zero_eq_iff.mpr ?_ + have h2 := congrArg (fun p => (p.2.1 : Matrix (Fin 2) (Fin 2) ℂ) i j) h + simpa [eval, evalSU, RingHom.mapMatrix_apply, Matrix.map_apply, + Matrix.one_apply, apply_ite constantCoeff] using h2 + · show JetRing.truncation 0 U.2.2.1 = JetRing.truncation 0 (1 : JetRing) + refine JetRing.truncation_zero_eq_iff.mpr ?_ + simpa [eval, evalU1] using congrArg (fun p => (p.2.2 : ℂ)) h + +@[simp] +lemma eval_coe_of_mem_truncationKer_zero (U : truncationKer 0) : U.1.eval = 1 := + mem_truncationKer_zero_iff.mp U.2 + +lemma self_mul_ofConstant_eval_mem (U : JetGaugeGroupI) : + U * (JetGaugeGroupI.ofConstant U.eval)⁻¹ ∈ truncationKer 0 := by + rw [mem_truncationKer_zero_iff] + simp + +/-! + +## The projection onto the zeroth truncation kernel + +-/ + +/-- The projection from `JetGaugeGroupI` onto the kernel of the zeroth truncation, + stripping the constant part: `U ↦ U · (U₀)⁻¹`. This is not a group homomorphism; + it is the group-level cocycle of the semidirect splitting of `JetGaugeGroupI` + by the constant jets. -/ +noncomputable def truncationProjZero (U : JetGaugeGroupI) : truncationKer 0 := + ⟨U * (JetGaugeGroupI.ofConstant U.eval)⁻¹, self_mul_ofConstant_eval_mem U⟩ + +lemma truncationProjZero_surjective : Function.Surjective truncationProjZero := by + intro V + refine ⟨V.1, Subtype.ext ?_⟩ + have h1 : V.1.eval = 1 := mem_truncationKer_zero_iff.mp V.2 + simp [truncationProjZero, h1] + +lemma truncationProjZero_eq_one_iff_constant {U : JetGaugeGroupI} : + truncationProjZero U = 1 ↔ ∃ c, U = .ofConstant c := by + constructor + · intro h + refine ⟨U.eval, ?_⟩ + have h1 : U * (JetGaugeGroupI.ofConstant U.eval)⁻¹ = 1 := congrArg Subtype.val h + exact mul_inv_eq_one.mp h1 + · rintro ⟨c, rfl⟩ + apply Subtype.ext + simp [truncationProjZero] + +lemma truncationProjZero_ofConstant (c : GaugeGroupI) : + truncationProjZero (JetGaugeGroupI.ofConstant c) = 1 := by + rw [truncationProjZero_eq_one_iff_constant] + exact ⟨c, rfl⟩ + +lemma eq_truncationProjZero_mul_ofConstant (U : JetGaugeGroupI) : + U = truncationProjZero U * JetGaugeGroupI.ofConstant U.eval := by + simp [truncationProjZero] + +end JetGaugeGroupI +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean new file mode 100644 index 000000000..3c1fc4112 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean @@ -0,0 +1,595 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +/-! +# The Maurer–Cartan forms of the jet gauge group + +The Maurer-Cartan form is a map +`ω : JetGaugeGroupI → (Fin 1 ⊕ Fin 3) → JetLieAlgebra` +defined as `ω_μ(U) := i (∂_μ U) U†`. + +We will use `ω^a_ν` to denote the `a`-th component of the Maurer–Cartan form in the +basis of the jet Lie algebra, and `f^a_{b c}` to denote the structure constants of the +jet Lie algebra in that basis. + +It satisfies the following properties: +- *Cocycle law*: `ω_μ(UV) = ω_μ(U) + U ω_μ(V) U†` +- *Value on the identity*: `ω_μ(1) = 0` +- *Value on constant gauge transformations*: `ω_μ(U₀) = 0` +- *Value on the inverse*: `ω_μ(U⁻¹) = -U⁻¹ ω_μ(U) U` +- *Structural equation*: `∂_μ ω^a_ν(U) − ∂_ν ω^a_μ(U) = ∑_{b c} f^a_{b c} · ω^b_μ(U) · ω^c_ν(U)` + +-/ + +@[expose] public section +namespace StandardModel +open MvPowerSeries + + + +/-! +# THis file is OLD!!!!!!!!!!! + + +!!!!!!!!!!!!! + +## The Maurer–Cartan forms of the jet gauge group + +-/ + + + +TODO "Define the symmetrized maurerCartan forms." + +/-- The `U(1)` Maurer–Cartan form of a jet of gauge transformations in the + direction `ν`: the series `i (∂_ν u) ū` for `u` the hypercharge factor of the + jet. -/ +noncomputable def maurerCartanU1 (g : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : JetRing := + (MvPowerSeries.C Complex.I : JetRing) * (pderiv ℂ ν (g.2.2 : JetRing) * star (g.2.2 : JetRing)) + +/-- The `SU(3)` Maurer–Cartan form of a jet of gauge transformations in the + direction `ν`: the matrix-valued series `i (∂_ν U) U†` for `U` the colour factor + of the jet, with the formal partial derivative applied entrywise and `star` the + conjugate transpose. -/ +noncomputable def maurerCartanSU3 (g : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + Matrix (Fin 3) (Fin 3) JetRing := + (MvPowerSeries.C Complex.I : JetRing) • + ((g.1 : Matrix (Fin 3) (Fin 3) JetRing).map (pderiv ℂ ν) * + star (g.1 : Matrix (Fin 3) (Fin 3) JetRing)) + +/-- The `SU(2)` Maurer–Cartan form of a jet of gauge transformations in the + direction `ν`: the matrix-valued series `i (∂_ν U) U†` for `U` the weak factor + of the jet, with the formal partial derivative applied entrywise and `star` the + conjugate transpose. -/ +noncomputable def maurerCartanSU2 (g : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + Matrix (Fin 2) (Fin 2) JetRing := + (MvPowerSeries.C Complex.I : JetRing) • + ((g.2.1 : Matrix (Fin 2) (Fin 2) JetRing).map (pderiv ℂ ν) * + star (g.2.1 : Matrix (Fin 2) (Fin 2) JetRing)) + +/-! + +### Basic properties of the Maurer–Cartan forms + +-/ + +@[simp] +lemma maurerCartanU1_one (ν : Fin 1 ⊕ Fin 3) : maurerCartanU1 1 ν = 0 := by + simp [maurerCartanU1, star_one] + +@[simp] +lemma maurerCartanSU3_one (ν : Fin 1 ⊕ Fin 3) : maurerCartanSU3 1 ν = 0 := by + ext i j + simp [maurerCartanSU3, Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ν)] + +@[simp] +lemma maurerCartanSU2_one (ν : Fin 1 ⊕ Fin 3) : maurerCartanSU2 1 ν = 0 := by + ext i j + simp [maurerCartanSU2, Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ν)] + +lemma maurerCartanU1_mul (g1 g2 : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanU1 (g1 * g2) ν = maurerCartanU1 g1 ν + maurerCartanU1 g2 ν := by + have hcoe : ((g1 * g2).2.2 : JetRing) = (g1.2.2 : JetRing) * (g2.2.2 : JetRing) := rfl + have h1 : (g1.2.2 : JetRing) * star (g1.2.2 : JetRing) = 1 := + (Unitary.mem_iff.mp g1.2.2.2).2 + have h2 : (g2.2.2 : JetRing) * star (g2.2.2 : JetRing) = 1 := + (Unitary.mem_iff.mp g2.2.2.2).2 + rw [maurerCartanU1, maurerCartanU1, maurerCartanU1, hcoe, Derivation.leibniz, star_mul'] + simp only [smul_eq_mul] + linear_combination ((MvPowerSeries.C Complex.I : JetRing) * + pderiv ℂ ν (g2.2.2 : JetRing) * star (g2.2.2 : JetRing)) * h1 + + ((MvPowerSeries.C Complex.I : JetRing) * + pderiv ℂ ν (g1.2.2 : JetRing) * star (g1.2.2 : JetRing)) * h2 + +/-- The cocycle law of the `SU(3)` Maurer–Cartan form: it is additive only up to + conjugating the second factor's form by the first factor, + `mc(UV) = mc(U) + U mc(V) U†`. -/ +lemma maurerCartanSU3_mul (g1 g2 : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanSU3 (g1 * g2) ν = + maurerCartanSU3 g1 ν + + (g1.1 : Matrix (Fin 3) (Fin 3) JetRing) * maurerCartanSU3 g2 ν * + star (g1.1 : Matrix (Fin 3) (Fin 3) JetRing) := by + have hcoe : ((g1 * g2).1 : Matrix (Fin 3) (Fin 3) JetRing) = + (g1.1 : Matrix (Fin 3) (Fin 3) JetRing) * (g2.1 : Matrix (Fin 3) (Fin 3) JetRing) := rfl + rw [maurerCartanSU3, maurerCartanSU3, maurerCartanSU3, hcoe] + set U : Matrix (Fin 3) (Fin 3) JetRing := (g1.1 : Matrix (Fin 3) (Fin 3) JetRing) + set V : Matrix (Fin 3) (Fin 3) JetRing := (g2.1 : Matrix (Fin 3) (Fin 3) JetRing) + have hV : V * star V = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp g2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hleib : (U * V).map (pderiv ℂ ν) = + U.map (pderiv ℂ ν) * V + U * V.map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + rw [hleib, star_mul, Matrix.add_mul, smul_add] + congr 1 + · rw [mul_assoc, ← mul_assoc V, hV, one_mul] + · rw [mul_smul_comm, smul_mul_assoc] + congr 1 + rw [mul_assoc, ← mul_assoc (V.map (pderiv ℂ ν)), ← mul_assoc U] + +lemma maurerCartanSU2_mul (g1 g2 : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanSU2 (g1 * g2) ν = + maurerCartanSU2 g1 ν + (g1.2.1 : Matrix (Fin 2) (Fin 2) JetRing) * maurerCartanSU2 g2 ν * + star (g1.2.1 : Matrix (Fin 2) (Fin 2) JetRing) := by + have hcoe : ((g1 * g2).2.1 : Matrix (Fin 2) (Fin 2) JetRing) = + (g1.2.1 : Matrix (Fin 2) (Fin 2) JetRing) * (g2.2.1 : Matrix (Fin 2) (Fin 2) JetRing) := rfl + rw [maurerCartanSU2, maurerCartanSU2, maurerCartanSU2, hcoe] + set U : Matrix (Fin 2) (Fin 2) JetRing := (g1.2.1 : Matrix (Fin 2) (Fin 2) JetRing) + set V : Matrix (Fin 2) (Fin 2) JetRing := (g2.2.1 : Matrix (Fin 2) (Fin 2) JetRing) + have hV : V * star V = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp g2.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hleib : (U * V).map (pderiv ℂ ν) = + U.map (pderiv ℂ ν) * V + U * V.map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + rw [hleib, star_mul, Matrix.add_mul, smul_add] + congr 1 + · rw [mul_assoc, ← mul_assoc V, hV, one_mul] + · rw [mul_smul_comm, smul_mul_assoc] + congr 1 + rw [mul_assoc, ← mul_assoc (V.map (pderiv ℂ ν)), ← mul_assoc U] + +/-- The `U(1)` Maurer–Cartan form of the inverse jet is the negative: the + abelian cocycle identity applied to `g g⁻¹ = 1`. -/ +lemma maurerCartanU1_inv (g : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanU1 g⁻¹ ν = -maurerCartanU1 g ν := by + have h := maurerCartanU1_mul g g⁻¹ ν + rw [mul_inv_cancel, maurerCartanU1_one] at h + exact eq_neg_of_add_eq_zero_right h.symm + +/-- The Maurer–Cartan form vanishes on jets of constant gauge transformations: + constants have vanishing derivative. -/ +@[simp] +lemma maurerCartanU1_ofConstant (g : GaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanU1 (JetGaugeGroupI.ofConstant g) ν = 0 := by + rw [maurerCartanU1, + show (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) = + MvPowerSeries.C ((g.2.2 : ℂ)) from rfl, + pderiv_C, zero_mul, mul_zero] + +/-- The `SU(3)` Maurer–Cartan form vanishes on jets of constant gauge + transformations: constants have vanishing derivative. -/ +@[simp] +lemma maurerCartanSU3_ofConstant (g : GaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanSU3 (JetGaugeGroupI.ofConstant g) ν = 0 := by + have hmap : ((JetGaugeGroupI.ofConstant g).1 : Matrix (Fin 3) (Fin 3) JetRing).map + (pderiv ℂ ν) = 0 := by + ext i j + rw [Matrix.map_apply, + show ((JetGaugeGroupI.ofConstant g).1 : Matrix (Fin 3) (Fin 3) JetRing) i j = + MvPowerSeries.C ((g.1 : Matrix (Fin 3) (Fin 3) ℂ) i j) from rfl, + pderiv_C] + rfl + rw [maurerCartanSU3, hmap, zero_mul, smul_zero] + +/-- The `SU(2)` Maurer–Cartan form vanishes on jets of constant gauge + transformations: constants have vanishing derivative. -/ +@[simp] +lemma maurerCartanSU2_ofConstant (g : GaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + maurerCartanSU2 (JetGaugeGroupI.ofConstant g) ν = 0 := by + have hmap : ((JetGaugeGroupI.ofConstant g).2.1 : Matrix (Fin 2) (Fin 2) JetRing).map + (pderiv ℂ ν) = 0 := by + ext i j + rw [Matrix.map_apply, + show ((JetGaugeGroupI.ofConstant g).2.1 : Matrix (Fin 2) (Fin 2) JetRing) i j = + MvPowerSeries.C ((g.2.1 : Matrix (Fin 2) (Fin 2) ℂ) i j) from rfl, + pderiv_C] + rfl + rw [maurerCartanSU2, hmap, zero_mul, smul_zero] + +/-- The Maurer–Cartan series is hermitian: `star (i (∂_ν u) ū) = i (∂_ν u) ū`, + by differentiating the unitarity relation `u ū = 1`. All its Taylor + coefficients are therefore real. -/ +lemma star_maurerCartanU1 (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + star (maurerCartanU1 U ν) = maurerCartanU1 U ν := by + have hu : (U.2.2 : JetRing) * star (U.2.2 : JetRing) = 1 := (Unitary.mem_iff.mp U.2.2.2).2 + have h0 : pderiv ℂ ν ((U.2.2 : JetRing) * star (U.2.2 : JetRing)) = 0 := by + rw [hu, pderiv_one] + rw [Derivation.leibniz] at h0 + simp only [smul_eq_mul] at h0 + have hq : pderiv ℂ ν (star (U.2.2 : JetRing)) * (U.2.2 : JetRing) = + -(pderiv ℂ ν (U.2.2 : JetRing) * star (U.2.2 : JetRing)) := by + linear_combination h0 + rw [maurerCartanU1, star_mul', JetRing.star_C, star_mul', star_star, ← JetRing.pderiv_star, hq, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_mul, mul_neg, neg_neg] + +/-- The `SU(3)` Maurer–Cartan form is hermitian: `(i (∂_ν U) U†)† = i (∂_ν U) U†`, + by differentiating the unitarity relation `U U† = 1` entrywise. -/ +lemma star_maurerCartanSU3 (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + star (maurerCartanSU3 U ν) = maurerCartanSU3 U ν := by + rw [maurerCartanSU3] + set A : Matrix (Fin 3) (Fin 3) JetRing := (U.1 : Matrix (Fin 3) (Fin 3) JetRing) with hA + have hU : A * star A = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hone : (1 : Matrix (Fin 3) (Fin 3) JetRing).map (pderiv ℂ ν) = 0 := by + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ν)] + have hleib : (A * star A).map (pderiv ℂ ν) = + A.map (pderiv ℂ ν) * star A + A * (star A).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have h0 : A.map (pderiv ℂ ν) * star A + A * (star A).map (pderiv ℂ ν) = 0 := by + rw [← hleib, hU, hone] + have hq : A * ((star A).map (pderiv ℂ ν)) = -(A.map (pderiv ℂ ν) * star A) := + eq_neg_of_add_eq_zero_right h0 + have hstarmap : star (A.map (pderiv ℂ ν)) = (star A).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.star_apply, Matrix.map_apply] + exact (JetRing.pderiv_star ν (A j i)).symm + rw [star_smul, star_mul, star_star, hstarmap, hq, JetRing.star_C, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_smul, smul_neg, neg_neg] + +/-- The `SU(2)` Maurer–Cartan form is hermitian; see `star_maurerCartanSU3`. -/ +lemma star_maurerCartanSU2 (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) : + star (maurerCartanSU2 U ν) = maurerCartanSU2 U ν := by + rw [maurerCartanSU2] + set A : Matrix (Fin 2) (Fin 2) JetRing := (U.2.1 : Matrix (Fin 2) (Fin 2) JetRing) with hA + have hU : A * star A = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hone : (1 : Matrix (Fin 2) (Fin 2) JetRing).map (pderiv ℂ ν) = 0 := by + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ν)] + have hleib : (A * star A).map (pderiv ℂ ν) = + A.map (pderiv ℂ ν) * star A + A * (star A).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have h0 : A.map (pderiv ℂ ν) * star A + A * (star A).map (pderiv ℂ ν) = 0 := by + rw [← hleib, hU, hone] + have hq : A * ((star A).map (pderiv ℂ ν)) = -(A.map (pderiv ℂ ν) * star A) := + eq_neg_of_add_eq_zero_right h0 + have hstarmap : star (A.map (pderiv ℂ ν)) = (star A).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.star_apply, Matrix.map_apply] + exact (JetRing.pderiv_star ν (A j i)).symm + rw [star_smul, star_mul, star_star, hstarmap, hq, JetRing.star_C, + show (star Complex.I) = -Complex.I by simp, map_neg, neg_smul, smul_neg, neg_neg] + +/-! + +### Derivatives of the Maurer–Cartan forms + +-/ + +lemma pderiv_maurerCartanU1_symm (u : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) : + pderiv ℂ μ (maurerCartanU1 u ν) = pderiv ℂ ν (maurerCartanU1 u μ) := by + have hu : (u.2.2 : JetRing) * star (u.2.2 : JetRing) = 1 := (Unitary.mem_iff.mp u.2.2.2).2 + have hu' : star (u.2.2 : JetRing) * (u.2.2 : JetRing) = 1 := (Unitary.mem_iff.mp u.2.2.2).1 + have hstar : ∀ ρ : Fin 1 ⊕ Fin 3, pderiv ℂ ρ (star (u.2.2 : JetRing)) = + -(star (u.2.2 : JetRing) * pderiv ℂ ρ (u.2.2 : JetRing) * star (u.2.2 : JetRing)) := by + intro ρ + have h0 : pderiv ℂ ρ ((u.2.2 : JetRing) * star (u.2.2 : JetRing)) = 0 := by + rw [hu, pderiv_one] + rw [Derivation.leibniz] at h0 + simp only [smul_eq_mul] at h0 + linear_combination star (u.2.2 : JetRing) * h0 - + (pderiv ℂ ρ (star (u.2.2 : JetRing))) * hu' + simp only [maurerCartanU1, Derivation.leibniz, pderiv_C, smul_eq_mul, mul_zero, add_zero] + rw [hstar μ, hstar ν, JetRing.pderiv_comm μ ν] + ring + +/-- The Maurer–Cartan structure equation for the `SU(3)` form: the antisymmetrized + derivative is the commutator, `∂_μ mc_ν - ∂_ν mc_μ = -i [mc_μ, mc_ν]`, here + stated additively. In the abelian `U(1)` case the commutator vanishes and this + reduces to `pderiv_maurerCartanU1_symm`. -/ +lemma pderiv_maurerCartanSU3_symm (u : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) : + (maurerCartanSU3 u ν).map (pderiv ℂ μ) + + (MvPowerSeries.C Complex.I : JetRing) • (maurerCartanSU3 u μ * maurerCartanSU3 u ν) = + (maurerCartanSU3 u μ).map (pderiv ℂ ν) + + (MvPowerSeries.C Complex.I : JetRing) • (maurerCartanSU3 u ν * maurerCartanSU3 u μ) := by + simp only [maurerCartanSU3] + set U : Matrix (Fin 3) (Fin 3) JetRing := (u.1 : Matrix (Fin 3) (Fin 3) JetRing) + have hU : U * star U = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp u.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hU' : star U * U = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp u.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h + have hone : ∀ ρ : Fin 1 ⊕ Fin 3, + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (pderiv ℂ ρ) = 0 := by + intro ρ + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ρ)] + have hleib : ∀ (ρ : Fin 1 ⊕ Fin 3) (A B : Matrix (Fin 3) (Fin 3) JetRing), + (A * B).map (pderiv ℂ ρ) = A.map (pderiv ℂ ρ) * B + A * B.map (pderiv ℂ ρ) := by + intro ρ A B + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have hstar : ∀ ρ : Fin 1 ⊕ Fin 3, (star U).map (pderiv ℂ ρ) = + -(star U * (U.map (pderiv ℂ ρ) * star U)) := by + intro ρ + have h0 : U.map (pderiv ℂ ρ) * star U + U * (star U).map (pderiv ℂ ρ) = 0 := by + rw [← hleib ρ U (star U), hU, hone] + have h1 : star U * (U.map (pderiv ℂ ρ) * star U) + + star U * (U * (star U).map (pderiv ℂ ρ)) = 0 := by + rw [← Matrix.mul_add, h0, mul_zero] + rw [show star U * (U * (star U).map (pderiv ℂ ρ)) = + star U * U * (star U).map (pderiv ℂ ρ) from (mul_assoc _ _ _).symm, hU', one_mul] at h1 + exact eq_neg_of_add_eq_zero_right h1 + have hCsmul : ∀ (ρ : Fin 1 ⊕ Fin 3) (A : Matrix (Fin 3) (Fin 3) JetRing), + ((MvPowerSeries.C Complex.I : JetRing) • A).map (pderiv ℂ ρ) = + (MvPowerSeries.C Complex.I : JetRing) • A.map (pderiv ℂ ρ) := by + intro ρ A + ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply, smul_eq_mul, Derivation.leibniz, + pderiv_C, mul_zero, add_zero] + have hDcomm : (U.map (pderiv ℂ ν)).map (pderiv ℂ μ) = + (U.map (pderiv ℂ μ)).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply] + exact JetRing.pderiv_comm μ ν (U i j) + have hI : (MvPowerSeries.C Complex.I : JetRing) * MvPowerSeries.C Complex.I = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hprod : ∀ (X Y : Matrix (Fin 3) (Fin 3) JetRing), + (MvPowerSeries.C Complex.I : JetRing) • + (((MvPowerSeries.C Complex.I : JetRing) • X) * + ((MvPowerSeries.C Complex.I : JetRing) • Y)) = + -((MvPowerSeries.C Complex.I : JetRing) • (X * Y)) := by + intro X Y + rw [smul_mul_assoc, mul_smul_comm, smul_smul, smul_smul, hI, neg_one_mul, neg_smul] + rw [hCsmul μ, hCsmul ν, hleib μ (U.map (pderiv ℂ ν)) (star U), + hleib ν (U.map (pderiv ℂ μ)) (star U), hstar μ, hstar ν, hDcomm, hprod, hprod] + simp only [mul_neg, smul_add, smul_neg, mul_assoc] + abel + +/-- The Maurer–Cartan structure equation for the `SU(2)` form; see + `pderiv_maurerCartanSU3_symm`. -/ +lemma pderiv_maurerCartanSU2_symm (u : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) : + (maurerCartanSU2 u ν).map (pderiv ℂ μ) + + (MvPowerSeries.C Complex.I : JetRing) • (maurerCartanSU2 u μ * maurerCartanSU2 u ν) = + (maurerCartanSU2 u μ).map (pderiv ℂ ν) + + (MvPowerSeries.C Complex.I : JetRing) • (maurerCartanSU2 u ν * maurerCartanSU2 u μ) := by + simp only [maurerCartanSU2] + set U : Matrix (Fin 2) (Fin 2) JetRing := (u.2.1 : Matrix (Fin 2) (Fin 2) JetRing) + have hU : U * star U = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp u.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hU' : star U * U = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp u.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h + have hone : ∀ ρ : Fin 1 ⊕ Fin 3, + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (pderiv ℂ ρ) = 0 := by + intro ρ + ext i j : 1 + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ρ)] + have hleib : ∀ (ρ : Fin 1 ⊕ Fin 3) (A B : Matrix (Fin 2) (Fin 2) JetRing), + (A * B).map (pderiv ℂ ρ) = A.map (pderiv ℂ ρ) * B + A * B.map (pderiv ℂ ρ) := by + intro ρ A B + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have hstar : ∀ ρ : Fin 1 ⊕ Fin 3, (star U).map (pderiv ℂ ρ) = + -(star U * (U.map (pderiv ℂ ρ) * star U)) := by + intro ρ + have h0 : U.map (pderiv ℂ ρ) * star U + U * (star U).map (pderiv ℂ ρ) = 0 := by + rw [← hleib ρ U (star U), hU, hone] + have h1 : star U * (U.map (pderiv ℂ ρ) * star U) + + star U * (U * (star U).map (pderiv ℂ ρ)) = 0 := by + rw [← Matrix.mul_add, h0, mul_zero] + rw [show star U * (U * (star U).map (pderiv ℂ ρ)) = + star U * U * (star U).map (pderiv ℂ ρ) from (mul_assoc _ _ _).symm, hU', one_mul] at h1 + exact eq_neg_of_add_eq_zero_right h1 + have hCsmul : ∀ (ρ : Fin 1 ⊕ Fin 3) (A : Matrix (Fin 2) (Fin 2) JetRing), + ((MvPowerSeries.C Complex.I : JetRing) • A).map (pderiv ℂ ρ) = + (MvPowerSeries.C Complex.I : JetRing) • A.map (pderiv ℂ ρ) := by + intro ρ A + ext i j : 1 + simp only [Matrix.map_apply, Matrix.smul_apply, smul_eq_mul, Derivation.leibniz, + pderiv_C, mul_zero, add_zero] + have hDcomm : (U.map (pderiv ℂ ν)).map (pderiv ℂ μ) = + (U.map (pderiv ℂ μ)).map (pderiv ℂ ν) := by + ext i j : 1 + simp only [Matrix.map_apply] + exact JetRing.pderiv_comm μ ν (U i j) + have hI : (MvPowerSeries.C Complex.I : JetRing) * MvPowerSeries.C Complex.I = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hprod : ∀ (X Y : Matrix (Fin 2) (Fin 2) JetRing), + (MvPowerSeries.C Complex.I : JetRing) • + (((MvPowerSeries.C Complex.I : JetRing) • X) * + ((MvPowerSeries.C Complex.I : JetRing) • Y)) = + -((MvPowerSeries.C Complex.I : JetRing) • (X * Y)) := by + intro X Y + rw [smul_mul_assoc, mul_smul_comm, smul_smul, smul_smul, hI, neg_one_mul, neg_smul] + rw [hCsmul μ, hCsmul ν, hleib μ (U.map (pderiv ℂ ν)) (star U), + hleib ν (U.map (pderiv ℂ μ)) (star U), hstar μ, hstar ν, hDcomm, hprod, hprod] + simp only [mul_neg, smul_add, smul_neg, mul_assoc] + abel + +/-! + +## The coefficents of the Maurer–Cartan forms + +-/ + +open JetRing + +/-- The Taylor coefficients of the Maurer–Cartan series, as hermitian scalars. -/ +noncomputable def maurerCartanU1Coeff (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) + (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : selfAdjoint ℂ := + ⟨coeff m (maurerCartanU1 U ν), by + rw [selfAdjoint.mem_iff, ← coeff_star, star_maurerCartanU1]⟩ + +@[simp] +lemma maurerCartanU1Coeff_one (ν : Fin 1 ⊕ Fin 3) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + maurerCartanU1Coeff 1 ν m = 0 := by + apply Subtype.ext + simp [maurerCartanU1Coeff] + +@[simp] +lemma maurerCartanU1Coeff_ofConstant (g : GaugeGroupI) (ν : Fin 1 ⊕ Fin 3) + (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + maurerCartanU1Coeff (JetGaugeGroupI.ofConstant g) ν m = 0 := by + apply Subtype.ext + simp [maurerCartanU1Coeff, maurerCartanU1_ofConstant] + +/-- The Taylor coefficients of the Maurer–Cartan series are additive in the jet. -/ +lemma maurerCartanU1Coeff_mul (U V : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) + (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + maurerCartanU1Coeff (U * V) ν m = maurerCartanU1Coeff U ν m + maurerCartanU1Coeff V ν m := by + apply Subtype.ext + simp [maurerCartanU1Coeff, maurerCartanU1_mul] + +/-- The first-order Taylor coefficients of the Maurer–Cartan series are symmetric + in the two spacetime directions: the shift of `∂_μ B_ν` equals the shift of + `∂_ν B_μ`. This is the gauge invariance of the abelian field strength, and rests + on unitarity: the antisymmetric part `∂_νu ∂_μū - ∂_μu ∂_νū` vanishes because + `∂ū = -ū (∂u) ū`. -/ +lemma maurerCartanU1Coeff_single_symm (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) : + maurerCartanU1Coeff U ν (Finsupp.single μ 1) = maurerCartanU1Coeff U μ (Finsupp.single ν 1) := by + rcases eq_or_ne μ ν with rfl | hμν + · rfl + apply Subtype.ext + show coeff (Finsupp.single μ 1) (maurerCartanU1 U ν) = coeff (Finsupp.single ν 1) (maurerCartanU1 U μ) + have hb : constantCoeff (U.2.2 : JetRing) * star (constantCoeff (U.2.2 : JetRing)) = 1 := by + have h := congrArg constantCoeff (Unitary.mem_iff.mp U.2.2.2).2 + rwa [map_mul, constantCoeff_star, map_one] at h + have hμ := congrArg (coeff (Finsupp.single μ 1)) (Unitary.mem_iff.mp U.2.2.2).2 + rw [coeff_single_one_mul, coeff_star, constantCoeff_star, + show coeff (Finsupp.single μ 1) (1 : JetRing) = 0 by + rw [coeff_one, if_neg (by simp [Finsupp.single_eq_zero])]] at hμ + have hν := congrArg (coeff (Finsupp.single ν 1)) (Unitary.mem_iff.mp U.2.2.2).2 + rw [coeff_single_one_mul, coeff_star, constantCoeff_star, + show coeff (Finsupp.single ν 1) (1 : JetRing) = 0 by + rw [coeff_one, if_neg (by simp [Finsupp.single_eq_zero])]] at hν + have hσμ : star (coeff (Finsupp.single μ 1) (U.2.2 : JetRing)) = + -(coeff (Finsupp.single μ 1) (U.2.2 : JetRing) * star (constantCoeff (U.2.2 : JetRing)) * + star (constantCoeff (U.2.2 : JetRing))) := by + linear_combination star (constantCoeff (U.2.2 : JetRing)) * hμ - + star (coeff (Finsupp.single μ 1) (U.2.2 : JetRing)) * hb + have hσν : star (coeff (Finsupp.single ν 1) (U.2.2 : JetRing)) = + -(coeff (Finsupp.single ν 1) (U.2.2 : JetRing) * star (constantCoeff (U.2.2 : JetRing)) * + star (constantCoeff (U.2.2 : JetRing))) := by + linear_combination star (constantCoeff (U.2.2 : JetRing)) * hν - + star (coeff (Finsupp.single ν 1) (U.2.2 : JetRing)) * hb + rw [maurerCartanU1, maurerCartanU1, + show ((C Complex.I : JetRing)) = algebraMap ℂ JetRing Complex.I from rfl, + ← Algebra.smul_def, ← Algebra.smul_def, map_smul, map_smul, smul_eq_mul, smul_eq_mul, + coeff_single_one_mul, coeff_single_one_mul, coeff_pderiv, coeff_pderiv, + coeff_star, coeff_star, constantCoeff_star, + show constantCoeff (pderiv ℂ ν (U.2.2 : JetRing)) = + coeff (Finsupp.single ν (1 : ℕ)) (U.2.2 : JetRing) from by + rw [← coeff_zero_eq_constantCoeff, coeff_pderiv] + simp, + show constantCoeff (pderiv ℂ μ (U.2.2 : JetRing)) = + coeff (Finsupp.single μ (1 : ℕ)) (U.2.2 : JetRing) from by + rw [← coeff_zero_eq_constantCoeff, coeff_pderiv] + simp, + show (Finsupp.single μ 1) ν = 0 from Finsupp.single_eq_of_ne hμν.symm, + show (Finsupp.single ν 1) μ = 0 from Finsupp.single_eq_of_ne hμν, + show Finsupp.single ν (1 : ℕ) + Finsupp.single μ 1 = + Finsupp.single μ 1 + Finsupp.single ν 1 from add_comm _ _, + hσμ, hσν] + push_cast + ring + +/-- The weighted symmetry of the Maurer–Cartan Taylor coefficients: exchanging the + field index with a derivative index changes the coefficient by the ratio of the + corresponding multiplicities. -/ +lemma maurerCartanU1Coeff_succ_symm (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) + (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + (m μ + 1) • maurerCartanU1Coeff U ν (m + Finsupp.single μ 1) = + (m ν + 1) • maurerCartanU1Coeff U μ (m + Finsupp.single ν 1) := by + have h := congrArg (coeff m) (pderiv_maurerCartanU1_symm U μ ν) + rw [coeff_pderiv, coeff_pderiv] at h + apply Subtype.ext + show ((m μ + 1 : ℕ)) • coeff (m + Finsupp.single μ 1) (maurerCartanU1 U ν) = + ((m ν + 1 : ℕ)) • coeff (m + Finsupp.single ν 1) (maurerCartanU1 U μ) + rw [nsmul_eq_mul, nsmul_eq_mul] + push_cast + linear_combination h + + +/-- The derivative of a hypercharge power of a `U(1)` jet: + `∂_ν (u^q) = -q i mc_ν u^q`, the all-orders form of the first-order Taylor + coefficient formula for the contragredient character. -/ +lemma pderiv_pow_unitary (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) (q : ℕ) : + pderiv ℂ ν ((U.2.2 : JetRing) ^ q) = + MvPowerSeries.C (-(q : ℂ) * Complex.I) * (maurerCartanU1 U ν * (U.2.2 : JetRing) ^ q) := by + rcases Nat.eq_zero_or_pos q with rfl | hq + · simp + · have h1 : star (U.2.2 : JetRing) * (U.2.2 : JetRing) = 1 := (Unitary.mem_iff.mp U.2.2.2).1 + have hpow : (U.2.2 : JetRing) ^ q = (U.2.2 : JetRing) * (U.2.2 : JetRing) ^ (q - 1) := by + conv_lhs => rw [show q = 1 + (q - 1) by omega, pow_add, pow_one] + have hC : (MvPowerSeries.C (-(q : ℂ) * Complex.I) : JetRing) * + MvPowerSeries.C Complex.I = MvPowerSeries.C ((q : ℕ) : ℂ) := by + rw [← map_mul] + congr 1 + ring_nf + rw [Complex.I_sq] + ring + have hN : (MvPowerSeries.C ((q : ℕ) : ℂ) : JetRing) = ((q : ℕ) : JetRing) := + map_natCast _ _ + rw [MvPowerSeries.pderiv_pow, maurerCartanU1, hpow] + linear_combination + (-((U.2.2 : JetRing) * (U.2.2 : JetRing) ^ (q - 1) * pderiv ℂ ν (U.2.2 : JetRing) * + star (U.2.2 : JetRing))) * hC + + (-((U.2.2 : JetRing) ^ (q - 1) * pderiv ℂ ν (U.2.2 : JetRing) * + MvPowerSeries.C ((q : ℕ) : ℂ))) * h1 + + (-((U.2.2 : JetRing) ^ (q - 1) * pderiv ℂ ν (U.2.2 : JetRing))) * hN + +/-- The derivative of a hypercharge power of the conjugate `U(1)` jet: + `∂_ν (ū^q) = q i mc_ν ū^q`, the conjugate-contragredient counterpart of + `pderiv_pow_unitary`. -/ +lemma pderiv_pow_unitary_star (U : JetGaugeGroupI) (ν : Fin 1 ⊕ Fin 3) (q : ℕ) : + pderiv ℂ ν (star (U.2.2 : JetRing) ^ q) = + MvPowerSeries.C ((q : ℂ) * Complex.I) * + (maurerCartanU1 U ν * star (U.2.2 : JetRing) ^ q) := by + have h := pderiv_pow_unitary U⁻¹ ν q + have hcoe : ((U⁻¹.2.2 : unitary JetRing) : JetRing) = + star ((U.2.2 : unitary JetRing) : JetRing) := by + rw [show (U⁻¹.2.2 : unitary JetRing) = (U.2.2)⁻¹ from rfl, ← Unitary.star_eq_inv, + Unitary.coe_star] + rw [hcoe, maurerCartanU1_inv, neg_mul, map_neg] at h + linear_combination h +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Basic.lean b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Basic.lean new file mode 100644 index 000000000..0b89d4d6f --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Basic.lean @@ -0,0 +1,656 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +/-! +# The Maurer–Cartan forms of the jet gauge group + +The Maurer-Cartan form is a map +`ω : JetGaugeGroupI → (Fin 1 ⊕ Fin 3) → JetGaugeAlgebra` +defined as `ω_μ(U) := i (∂_μ U) U†`. + +We will use `ω^a_ν` to denote the `a`-th component of the Maurer–Cartan form in the +basis of the jet Lie algebra, and `f^a_{b c}` to denote the structure constants of the +jet Lie algebra in that basis. + +It satisfies the following properties: +- *Cocycle law*: `ω_μ(UV) = ω_μ(U) + U ω_μ(V) U†` +- *Value on the identity*: `ω_μ(1) = 0` +- *Value on constant gauge transformations*: `ω_μ(U₀) = 0` +- *Value on the inverse*: `ω_μ(U⁻¹) = -U⁻¹ ω_μ(U) U` +- *Structural equation*: `∂_μ ω^a_ν(U) − ∂_ν ω^a_μ(U) = ∑_{b c} f^a_{b c} · ω^b_μ(U) · ω^c_ν(U)` + +-/ + +@[expose] public section +namespace StandardModel +open MvPowerSeries JetGaugeAlgebra + +/-! + +## The Maurer–Cartan form of the jet gauge group + +-/ + +/-- The Maurer–Cartan form `ω_μ(U) := i (∂_μ U) U⁻¹` of the jet gauge group, valued + in the jet gauge algebra. -/ +noncomputable def maurerCartanForm (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : JetGaugeAlgebra := + JetGaugeAlgebra.ofMatrixProd (Complex.I • (JetGaugeGroupI.deriv μ U * (U⁻¹).toVal)) + ⟨JetGaugeGroupI.star_deriv_mul_inv_toVal_SU3 μ U, + JetGaugeGroupI.deriv_mul_inv_toVal_SU3_traceless μ U⟩ + ⟨JetGaugeGroupI.star_deriv_mul_inv_toVal_SU2 μ U, + JetGaugeGroupI.deriv_mul_inv_toVal_SU2_traceless μ U⟩ + (JetGaugeGroupI.star_deriv_mul_inv_toVal_U1 μ U) + +@[simp] +lemma maurerCartanForm_toSU3Matrix (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (maurerCartanForm U μ).toSU3Matrix = + Complex.I • (U.1.1.map (pderiv ℂ μ) * star U.1.1) := rfl + +@[simp] +lemma maurerCartanForm_toSU2Matrix (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (maurerCartanForm U μ).toSU2Matrix = + Complex.I • (U.2.1.1.map (pderiv ℂ μ) * star U.2.1.1) := rfl + +@[simp] +lemma maurerCartanForm_toU1Value (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (maurerCartanForm U μ).toU1Value = + Complex.I • (pderiv ℂ μ U.2.2.1 * star U.2.2.1) := rfl + +@[simp] +lemma maurerCartanForm_one : maurerCartanForm (1 : JetGaugeGroupI) = 0 := by + ext <;> simp [maurerCartanForm,JetGaugeGroupI.deriv_one] + +lemma maurerCartanForm_ofConstant (U₀ : GaugeGroupI) : + maurerCartanForm (JetGaugeGroupI.ofConstant U₀) = 0 := by + ext <;> simp [maurerCartanForm,JetGaugeGroupI.deriv_ofConstant] + +lemma maurerCartanForm_cocycle (U V : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + maurerCartanForm (U * V) μ = maurerCartanForm U μ + adjoint U (maurerCartanForm V μ) := by + have h1 : V.toVal * (V⁻¹).toVal = 1 := by + rw [show V.toVal * (V⁻¹).toVal = (V * V⁻¹).toVal from rfl, mul_inv_cancel]; rfl + have key : Complex.I • (JetGaugeGroupI.deriv μ (U * V) * ((U * V)⁻¹).toVal) = + Complex.I • (JetGaugeGroupI.deriv μ U * (U⁻¹).toVal) + + U.toVal * (Complex.I • (JetGaugeGroupI.deriv μ V * (V⁻¹).toVal)) * (U⁻¹).toVal := by + rw [show ((U * V)⁻¹).toVal = (V⁻¹).toVal * (U⁻¹).toVal from by rw [mul_inv_rev]; rfl, + JetGaugeGroupI.deriv_mul, add_mul, smul_add, mul_smul_comm, smul_mul_assoc] + congr 1 + · rw [mul_assoc (JetGaugeGroupI.deriv μ U), ← mul_assoc V.toVal, h1, one_mul] + · simp [mul_assoc] + refine ext_of_matrix (congrArg (fun p => p.1) key) (congrArg (fun p => p.2.1) key) ?_ + have h22 : (maurerCartanForm (U * V) μ).toU1Value = + (maurerCartanForm U μ).toU1Value + + U.2.2.1 * (maurerCartanForm V μ).toU1Value * star U.2.2.1 := + congrArg (fun p => p.2.2) key + rw [h22, mul_comm (U.2.2.1 : JetRing) ((maurerCartanForm V μ).toU1Value), mul_assoc, + (Unitary.mem_iff.mp U.2.2.2).2, mul_one] + rfl + +lemma maurerCartanForm_inv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + maurerCartanForm (U⁻¹) μ = - adjoint U⁻¹ (maurerCartanForm U μ) := by + linear_combination (norm := simp) -(maurerCartanForm_cocycle U⁻¹ U μ) + +lemma deriv_zero_of_maurerCartanForm_zero (U : JetGaugeGroupI) (h : maurerCartanForm U = 0) : + ∀ μ, U.deriv μ = 0 := by + intro μ + have h1 : maurerCartanForm U μ = 0 := congrFun h μ + -- extract the underlying value triple of the vanishing algebra element + have h2 : Complex.I • (JetGaugeGroupI.deriv μ U * (U⁻¹).toVal) = 0 := + Prod.ext (congrArg (fun a => a.1.1) h1) + (Prod.ext (congrArg (fun a => a.2.1.1) h1) (congrArg (fun a => a.2.2.1) h1)) + -- cancel the scalar `i` + have hml : (-Complex.I) * Complex.I = 1 := by simp [neg_mul, Complex.I_mul_I] + have h3 : JetGaugeGroupI.deriv μ U * (U⁻¹).toVal = 0 := by + have h4 := congrArg (fun X => (-Complex.I) • X) h2 + simpa [smul_smul, hml] using h4 + -- cancel `U⁻¹` on the right + have h5 : (U⁻¹).toVal * U.toVal = 1 := by + rw [show (U⁻¹).toVal * U.toVal = (U⁻¹ * U).toVal from rfl, inv_mul_cancel] + rfl + calc JetGaugeGroupI.deriv μ U + = JetGaugeGroupI.deriv μ U * ((U⁻¹).toVal * U.toVal) := by rw [h5, mul_one] + _ = JetGaugeGroupI.deriv μ U * (U⁻¹).toVal * U.toVal := by rw [mul_assoc] + _ = 0 := by rw [h3, zero_mul] + +lemma maurerCartanForm_eq_zero_iff_ofConstant (U : JetGaugeGroupI) : + maurerCartanForm U = 0 ↔ ∃ c, U = JetGaugeGroupI.ofConstant c := by + constructor + · intro h + -- Step 1: all first derivatives of `U` vanish. + have hderiv := deriv_zero_of_maurerCartanForm_zero U h + -- Step 2: a jet with vanishing first derivatives is the constant jet of its value. + have hconst : ∀ f : JetRing, (∀ μ, pderiv ℂ μ f = 0) → f = C (constantCoeff f) := by + intro f hf + refine pderiv.ext (fun i => ?_) ?_ + · rw [hf i, pderiv_C] + · rw [constantCoeff_C] + refine ⟨U.eval, Prod.ext (Subtype.ext ?_) (Prod.ext (Subtype.ext ?_) (Subtype.ext ?_))⟩ + · show U.1.1 = ((JetGaugeGroupI.ofConstant U.eval).1 : Matrix (Fin 3) (Fin 3) JetRing) + ext i j : 1 + exact hconst (U.1.1 i j) fun μ => by + simpa [JetGaugeGroupI.deriv, Matrix.map_apply] using + congrArg (fun p => (p.1 : Matrix (Fin 3) (Fin 3) JetRing) i j) (hderiv μ) + · show U.2.1.1 = ((JetGaugeGroupI.ofConstant U.eval).2.1 : Matrix (Fin 2) (Fin 2) JetRing) + ext i j : 1 + exact hconst (U.2.1.1 i j) fun μ => by + simpa [JetGaugeGroupI.deriv, Matrix.map_apply] using + congrArg (fun p => (p.2.1 : Matrix (Fin 2) (Fin 2) JetRing) i j) (hderiv μ) + · show U.2.2.1 = ((JetGaugeGroupI.ofConstant U.eval).2.2 : JetRing) + exact hconst U.2.2.1 fun μ => congrArg (fun p => (p.2.2 : JetRing)) (hderiv μ) + · rintro ⟨c, rfl⟩ + exact maurerCartanForm_ofConstant c + +/-! + +## The structural equation + +-/ + +/-- The structural (Maurer–Cartan) equation, basis-independently: the Maurer–Cartan + form is flat, + + `∂_μ ω_ν − ∂_ν ω_μ + ⁅ω_μ, ω_ν⁆ = 0`. + + In components with respect to a basis of the jet gauge algebra this is + `∂_μ ω^a_ν − ∂_ν ω^a_μ = ∑_{b c} f^a_{b c} · ω^b_μ · ω^c_ν`. On each matrix + factor the second-derivative terms cancel by symmetry of mixed partials, the + derivative of `A†` is rewritten through the differentiated unitarity relation, + and the surviving first-order terms form the commutator; on the abelian `U(1)` + factor the commutator is absent and only the symmetry of mixed partials + remains. -/ +lemma maurerCartanForm_structure (U : JetGaugeGroupI) (μ ν : Fin 1 ⊕ Fin 3) : + deriv μ (maurerCartanForm U ν) - deriv ν (maurerCartanForm U μ) + + ⁅maurerCartanForm U μ, maurerCartanForm U ν⁆ = 0 := by + -- pulling the scalar `i` out of the entrywise formal derivative + have hmap : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (ρ : Fin 1 ⊕ Fin 3) (c : ℂ) + (M : Matrix κ κ JetRing), (c • M).map (pderiv ℂ ρ) = c • M.map (pderiv ℂ ρ) := + fun _ _ _ _ _ _ => Matrix.ext fun _ _ => Derivation.map_smul _ _ _ + -- the matrix-level structural identity, generic in the size of the factor + have key : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (A : Matrix κ κ JetRing), + A * star A = 1 → + (A.map (pderiv ℂ ν) * star A).map (pderiv ℂ μ) - + (A.map (pderiv ℂ μ) * star A).map (pderiv ℂ ν) = + A.map (pderiv ℂ μ) * star A * (A.map (pderiv ℂ ν) * star A) - + A.map (pderiv ℂ ν) * star A * (A.map (pderiv ℂ μ) * star A) := by + intro κ _ _ A hU + have hleib : ∀ (ρ : Fin 1 ⊕ Fin 3) (M N : Matrix κ κ JetRing), + (M * N).map (pderiv ℂ ρ) = M.map (pderiv ℂ ρ) * N + M * N.map (pderiv ℂ ρ) := by + intro ρ M N + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + -- the derivative of `A†` through differentiated unitarity + have hq : ∀ ρ : Fin 1 ⊕ Fin 3, + (star A).map (pderiv ℂ ρ) = -(star A * A.map (pderiv ℂ ρ) * star A) := by + intro ρ + have h1 : A * (star A).map (pderiv ℂ ρ) = -(A.map (pderiv ℂ ρ) * star A) := + eq_neg_of_add_eq_zero_right (by + rw [← hleib ρ A (star A), hU] + exact Matrix.ext fun i j => by + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ρ)]) + calc (star A).map (pderiv ℂ ρ) + = star A * A * (star A).map (pderiv ℂ ρ) := by + rw [mul_eq_one_comm.mp hU, one_mul] + _ = -(star A * A.map (pderiv ℂ ρ) * star A) := by + rw [mul_assoc, h1, mul_neg, ← mul_assoc] + rw [hleib μ (A.map (pderiv ℂ ν)) (star A), hleib ν (A.map (pderiv ℂ μ)) (star A), + show (A.map (pderiv ℂ ν)).map (pderiv ℂ μ) = (A.map (pderiv ℂ μ)).map (pderiv ℂ ν) + from Matrix.ext fun _ _ => JetRing.pderiv_comm μ ν _, hq μ, hq ν] + simp only [mul_neg, ← mul_assoc] + abel + -- the abelian `U(1)` identity: no commutator, pure symmetry of mixed partials + have keyU1 : pderiv ℂ μ (pderiv ℂ ν U.2.2.1 * star U.2.2.1) = + pderiv ℂ ν (pderiv ℂ μ U.2.2.1 * star U.2.2.1) := by + have hu : U.2.2.1 * star U.2.2.1 = 1 := (Unitary.mem_iff.mp U.2.2.2).2 + have hstar : ∀ ρ : Fin 1 ⊕ Fin 3, pderiv ℂ ρ (star U.2.2.1) = + -(star U.2.2.1 * pderiv ℂ ρ U.2.2.1 * star U.2.2.1) := by + intro ρ + have h0 : pderiv ℂ ρ (U.2.2.1 * star U.2.2.1) = 0 := by rw [hu, pderiv_one] + rw [Derivation.leibniz] at h0 + simp only [smul_eq_mul] at h0 + linear_combination star U.2.2.1 * h0 - + pderiv ℂ ρ (star U.2.2.1) * ((mul_comm _ _).trans hu) + simp only [Derivation.leibniz, smul_eq_mul] + rw [hstar μ, hstar ν, JetRing.pderiv_comm μ ν] + ring + refine ext_of_matrix ?_ ?_ ?_ <;> + simp only [add_toSU3Matrix, add_toSU2Matrix, add_toU1Value, sub_toSU3Matrix, + sub_toSU2Matrix, sub_toU1Value, deriv_toSU3Matrix, deriv_toSU2Matrix, + deriv_toU1Value, bracket_toSU3Matrix, bracket_toSU2Matrix, bracket_toU1Value, + maurerCartanForm_toSU3Matrix, maurerCartanForm_toSU2Matrix, + maurerCartanForm_toU1Value, zero_toSU3Matrix, zero_toSU2Matrix, zero_toU1Value, + hmap, smul_mul_smul_comm, Complex.I_mul_I, neg_one_smul, Derivation.map_smul, + add_zero] + · rw [← smul_sub, ← smul_add, key _ U.1.1 + (Matrix.mem_unitaryGroup_iff.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1)] + exact smul_eq_zero_of_right _ (by abel) + · rw [← smul_sub, ← smul_add, key _ U.2.1.1 + (Matrix.mem_unitaryGroup_iff.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1)] + exact smul_eq_zero_of_right _ (by abel) + · rw [keyU1, sub_self] + +/-! + +## Integrating the structural equation + +-/ + +/-- The integration step of the converse to the structural equation: a flat jet + 1-form `ω` is the logarithmic derivative of a jet of gauge transformations based + at the identity, `∂_μ U = −i ω_μ · U` with `U(0) = 1`. Combined with unitarity + this says `ω_μ = i (∂_μ U) U⁻¹`, i.e. `ω` is the Maurer–Cartan form of a pure + jet; existence there is `exists_maurerCartanForm_eq_of_structure`. -/ +lemma exists_deriv_eq_of_maurerCartanForm_structure + (ω : (Fin 1 ⊕ Fin 3) → JetGaugeAlgebra) + (hω : ∀ μ ν, deriv μ (ω ν) - deriv ν (ω μ) + ⁅ω μ, ω ν⁆ = 0) : + ∃ U : JetGaugeGroupI, U.eval = 1 ∧ ∀ μ, + JetGaugeGroupI.deriv μ U = (-Complex.I) • (ω μ).toVal * U.toVal := by + -- entrywise toolkit: `pderiv` through scalars, products, stars; constancy of jets + have hmap : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (ρ : Fin 1 ⊕ Fin 3) (c : ℂ) + (M : Matrix κ κ JetRing), (c • M).map (pderiv ℂ ρ) = c • M.map (pderiv ℂ ρ) := + fun _ _ _ _ _ _ => Matrix.ext fun _ _ => Derivation.map_smul _ _ _ + have hleib : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (ρ : Fin 1 ⊕ Fin 3) + (M N : Matrix κ κ JetRing), + (M * N).map (pderiv ℂ ρ) = M.map (pderiv ℂ ρ) * N + M * N.map (pderiv ℂ ρ) := by + intro κ _ _ ρ M N + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have hstarmap : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (ρ : Fin 1 ⊕ Fin 3) + (M : Matrix κ κ JetRing), (star M).map (pderiv ℂ ρ) = star (M.map (pderiv ℂ ρ)) := + fun _ _ _ ρ M => Matrix.ext fun i j => JetRing.pderiv_star ρ (M j i) + have hconst : ∀ f : JetRing, (∀ μ, pderiv ℂ μ f = 0) → f = C (constantCoeff f) := + fun f hf => pderiv.ext (fun i => by rw [hf i, pderiv_C]) (by rw [constantCoeff_C]) + have hconstM : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (M : Matrix κ κ JetRing), + (constantCoeff : JetRing →+* ℂ).mapMatrix M = 1 → + (∀ μ, M.map (pderiv ℂ μ) = 0) → M = 1 := by + intro κ _ _ M h1 hM + ext i j + rw [hconst (M i j) fun μ => congrArg (fun N => N i j) (hM μ), + show constantCoeff (M i j) = (1 : Matrix κ κ ℂ) i j from congrArg (fun N => N i j) h1] + simp [Matrix.one_apply, apply_ite (fun c : ℂ => (C c : JetRing))] + -- generic integration: flat hermitian data has a unitary Wilson line based at `1` + have hmain : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] + (X : (Fin 1 ⊕ Fin 3) → Matrix κ κ JetRing), (∀ μ, star (X μ) = X μ) → + (∀ μ ν, (X ν).map (pderiv ℂ μ) - (X μ).map (pderiv ℂ ν) + + Complex.I • (X μ * X ν - X ν * X μ) = 0) → + ∃ F : Matrix κ κ JetRing, (constantCoeff : JetRing →+* ℂ).mapMatrix F = 1 ∧ + F * star F = 1 ∧ ∀ μ, F.map (pderiv ℂ μ) = (-Complex.I) • X μ * F := by + intro κ _ _ X hXstar hXflat + obtain ⟨F, hF0, hF⟩ := JetRing.exists_parallelTransport (fun μ => (-Complex.I) • X μ) + (fun μ ν => by + simp only [hmap, smul_mul_smul_comm] + linear_combination (norm := module) (-Complex.I) • hXflat μ ν) + replace hF : ∀ μ, F.map (pderiv ℂ μ) = (-Complex.I) • X μ * F := hF + have hA : ∀ μ, star ((-Complex.I) • X μ) = -((-Complex.I) • X μ) := fun μ => by + rw [star_smul, hXstar μ] + simp + refine ⟨F, hF0, mul_eq_one_comm.mp (hconstM _ _ ?_ fun μ => ?_), hF⟩ + · rw [map_mul, JetRing.mapMatrix_constantCoeff_star, hF0, star_one, one_mul] + · rw [hleib, hstarmap, hF, star_mul, hA, mul_neg, neg_mul, mul_assoc, neg_add_cancel] + -- the determinant of a Wilson line of traceless data is constant, hence `1` + have hdet : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] + (X : (Fin 1 ⊕ Fin 3) → Matrix κ κ JetRing) (F : Matrix κ κ JetRing), + (∀ (M : Matrix κ κ JetRing) (μ : Fin 1 ⊕ Fin 3), + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace) → + (∀ μ, (X μ).trace = 0) → (constantCoeff : JetRing →+* ℂ).mapMatrix F = 1 → + (∀ μ, F.map (pderiv ℂ μ) = (-Complex.I) • X μ * F) → F.det = 1 := by + intro κ _ _ X F hjac htr h0 hF + rw [hconst F.det fun μ => by + rw [hjac F μ, hF μ, Matrix.mul_assoc, Matrix.mul_adjugate, mul_smul_comm, mul_one, + Matrix.trace_smul, Matrix.trace_smul, htr μ, smul_zero, smul_zero], + RingHom.map_det, h0, Matrix.det_one, map_one] + -- Jacobi's formula on each matrix factor + have hjac3 : ∀ (M : Matrix (Fin 3) (Fin 3) JetRing) (μ : Fin 1 ⊕ Fin 3), + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace := by + intro M μ + rw [Matrix.det_fin_three] + simp only [Matrix.trace_fin_three, Matrix.mul_apply, Fin.sum_univ_three, + Matrix.map_apply, Matrix.adjugate_fin_three, Matrix.of_apply, Matrix.cons_val', + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, Matrix.head_cons, + Matrix.tail_cons, Matrix.head_fin_const, Matrix.empty_val', Matrix.cons_val_fin_one, + map_sub, map_add, Derivation.leibniz, smul_eq_mul] + ring + have hjac2 : ∀ (M : Matrix (Fin 2) (Fin 2) JetRing) (μ : Fin 1 ⊕ Fin 3), + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace := by + intro M μ + rw [Matrix.det_fin_two] + simp only [Matrix.adjugate_fin_two, Matrix.trace_fin_two, Matrix.mul_apply, + Matrix.map_apply, Matrix.of_apply, Matrix.cons_val', Matrix.cons_val_zero, + Matrix.empty_val', Matrix.cons_val_fin_one, Fin.sum_univ_two, Matrix.cons_val_one, + map_sub, Derivation.leibniz, smul_eq_mul] + ring + -- integrate each factor + obtain ⟨F₃, hF₃0, hF₃u, hF₃⟩ := hmain (Fin 3) (fun μ => (ω μ).toSU3Matrix) + (fun μ => show star (ω μ).toSU3Matrix = (ω μ).toSU3Matrix from (ω μ).1.2.1) + (fun μ ν => by + simpa only [sub_toSU3Matrix, add_toSU3Matrix, deriv_toSU3Matrix, bracket_toSU3Matrix, + zero_toSU3Matrix] using congrArg toSU3Matrix (hω μ ν)) + obtain ⟨F₂, hF₂0, hF₂u, hF₂⟩ := hmain (Fin 2) (fun μ => (ω μ).toSU2Matrix) + (fun μ => show star (ω μ).toSU2Matrix = (ω μ).toSU2Matrix from (ω μ).2.1.2.1) + (fun μ ν => by + simpa only [sub_toSU2Matrix, add_toSU2Matrix, deriv_toSU2Matrix, bracket_toSU2Matrix, + zero_toSU2Matrix] using congrArg toSU2Matrix (hω μ ν)) + obtain ⟨F₁, hF₁0, hF₁u, hF₁⟩ := hmain (Fin 1) + (fun μ => Matrix.of fun _ _ => (ω μ).toU1Value) + (fun μ => Matrix.ext fun _ _ => (ω μ).2.2.2) + (fun μ ν => by + have h := congrArg toU1Value (hω μ ν) + simp only [sub_toU1Value, add_toU1Value, deriv_toU1Value, bracket_toU1Value, + zero_toU1Value, add_zero] at h + ext i j + simp [Matrix.mul_apply, mul_comm, h]) + have hd₃ : F₃.det = 1 := hdet (Fin 3) (fun μ => (ω μ).toSU3Matrix) F₃ hjac3 + (fun μ => show ((ω μ).toSU3Matrix).trace = 0 from (ω μ).1.2.2) hF₃0 hF₃ + have hd₂ : F₂.det = 1 := hdet (Fin 2) (fun μ => (ω μ).toSU2Matrix) F₂ hjac2 + (fun μ => show ((ω μ).toSU2Matrix).trace = 0 from (ω μ).2.1.2.2) hF₂0 hF₂ + -- extract the `U(1)` scalar + have hu1 : F₁ 0 0 * star (F₁ 0 0) = 1 := by + simpa [Matrix.mul_apply] using congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) hF₁u + have hu0 : constantCoeff (F₁ 0 0) = 1 := by + simpa using congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) hF₁0 + -- assemble the jet gauge transformation + refine ⟨⟨⟨F₃, Matrix.mem_specialUnitaryGroup_iff.mpr + ⟨Matrix.mem_unitaryGroup_iff.mpr hF₃u, hd₃⟩⟩, + ⟨F₂, Matrix.mem_specialUnitaryGroup_iff.mpr + ⟨Matrix.mem_unitaryGroup_iff.mpr hF₂u, hd₂⟩⟩, + ⟨F₁ 0 0, Unitary.mem_iff.mpr ⟨by rw [mul_comm]; exact hu1, hu1⟩⟩⟩, + Prod.ext (Subtype.ext hF₃0) (Prod.ext (Subtype.ext hF₂0) (Subtype.ext hu0)), + fun μ => Prod.ext (hF₃ μ) (Prod.ext (hF₂ μ) ?_)⟩ + show pderiv ℂ μ (F₁ 0 0) = (-Complex.I) • (ω μ).toU1Value * F₁ 0 0 + simpa [Matrix.mul_apply] using congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) (hF₁ μ) + +/-! + +## The symmeterized Maurer–Cartan form + +-/ + + +noncomputable def symmetrizedMaurerCartanForm (U : JetGaugeGroupI) + (r : Multiset (Fin 1 ⊕ Fin 3)) : JetGaugeAlgebra := + ((1/(r.card : ℝ) : ℝ) • (r.map fun μ => + (iteratedDeriv (r - {μ}) (maurerCartanForm U μ))).sum) + +@[simp] +lemma symmetrizedMaurerCartanForm_apply_zero (U : JetGaugeGroupI) : + symmetrizedMaurerCartanForm U 0 = 0 := by + simp [symmetrizedMaurerCartanForm] + +@[simp] +lemma symmetrizedMaurerCartanForm_one : + symmetrizedMaurerCartanForm (1 : JetGaugeGroupI) = 0 := by + ext <;> simp [symmetrizedMaurerCartanForm] + +@[simp] +lemma symmetrizedMaurerCartanForm_ofConstant (U₀ : GaugeGroupI) : + symmetrizedMaurerCartanForm (JetGaugeGroupI.ofConstant U₀) = 0 := by + ext <;> simp [symmetrizedMaurerCartanForm, maurerCartanForm_ofConstant] + +@[simp] +lemma symmetrizedMaurerCartanForm_singleton (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + symmetrizedMaurerCartanForm U {μ} = (maurerCartanForm U μ) := by + simp [symmetrizedMaurerCartanForm, iteratedDeriv_zero] + +/-- The recursion for the symmetrized Maurer–Cartan form: peeling one direction off the + multiset. -/ +lemma symmetrizedMaurerCartanForm_cons (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) + (r : Multiset (Fin 1 ⊕ Fin 3)) : symmetrizedMaurerCartanForm U (μ ::ₘ r) = + (1/(r.card + 1 : ℝ) : ℝ) • (iteratedDeriv r (maurerCartanForm U μ)) + + ((r.card : ℝ)/(r.card + 1 : ℝ)) • deriv μ (symmetrizedMaurerCartanForm U r) := by + by_cases hr : r = 0 + · subst hr + simp + · have hn : (r.card : ℝ) ≠ 0 := + Nat.cast_ne_zero.mpr fun h => hr (Multiset.card_eq_zero.mp h) + have herase : ∀ ν ∈ r, (μ ::ₘ r).erase ν = μ ::ₘ r.erase ν := by + intro ν hν + rcases eq_or_ne ν μ with rfl | h + · rw [Multiset.erase_cons_head, Multiset.cons_erase hν] + · rw [Multiset.erase_cons_tail _ h.symm] + rw [symmetrizedMaurerCartanForm, symmetrizedMaurerCartanForm, Multiset.map_cons, + Multiset.sum_cons, Multiset.card_cons, Multiset.sub_singleton, Multiset.erase_cons_head, + Multiset.map_congr rfl fun ν hν => by + rw [Multiset.sub_singleton, herase ν hν, iteratedDeriv_cons, LinearMap.comp_apply, + ← Multiset.sub_singleton], + show (r.map fun ν => deriv μ (iteratedDeriv (r - {ν}) (maurerCartanForm U ν))) = + (r.map fun ν => iteratedDeriv (r - {ν}) (maurerCartanForm U ν)).map (deriv μ) from + (Multiset.map_map _ _ _).symm, + ← map_multiset_sum, smul_add, map_smul, smul_smul, + show ((r.card + 1 : ℕ) : ℝ) = (r.card : ℝ) + 1 by push_cast; ring, + show (r.card : ℝ)/((r.card : ℝ) + 1) * (1/(r.card : ℝ)) = 1/((r.card : ℝ) + 1) by + field_simp] + +/-! + +## Determination of the Maurer–Cartan form by its symmetrized coefficients + +-/ + + +/-- The symmetrization defect of the Maurer–Cartan form: an iterated derivative of + `ω` is the corresponding symmetrized form plus an average of iterated derivatives + of brackets of `ω` in strictly fewer directions. This is the jet-level form of the + outline's span statement, with the structure equation already substituted. -/ +lemma iteratedDeriv_maurerCartanForm_eq_symmetrized_add (U : JetGaugeGroupI) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + iteratedDeriv s (maurerCartanForm U μ) = + symmetrizedMaurerCartanForm U (μ ::ₘ s) + + (1/(s.card + 1 : ℝ)) • (s.map fun ν => + iteratedDeriv (s.erase ν) ⁅maurerCartanForm U μ, maurerCartanForm U ν⁆).sum := by + -- each bracket term is a difference of two iterated derivatives of `ω` + have hswap : ∀ ν ∈ s, + iteratedDeriv (s.erase ν) ⁅maurerCartanForm U μ, maurerCartanForm U ν⁆ = + iteratedDeriv s (maurerCartanForm U μ) - + iteratedDeriv (μ ::ₘ s.erase ν) (maurerCartanForm U ν) := by + intro ν hν + have hb : ⁅maurerCartanForm U μ, maurerCartanForm U ν⁆ = + deriv ν (maurerCartanForm U μ) - deriv μ (maurerCartanForm U ν) := by + have h1 : deriv μ (maurerCartanForm U ν) - deriv ν (maurerCartanForm U μ) = + -⁅maurerCartanForm U μ, maurerCartanForm U ν⁆ := + eq_neg_of_add_eq_zero_left (maurerCartanForm_structure U μ ν) + rw [← neg_sub, h1, neg_neg] + rw [hb, map_sub] + congr 1 + · conv_rhs => rw [← Multiset.cons_erase hν] + rw [show (ν ::ₘ s.erase ν : Multiset (Fin 1 ⊕ Fin 3)) = s.erase ν + {ν} from by + rw [add_comm, Multiset.singleton_add], + iteratedDeriv_add, LinearMap.comp_apply, iteratedDeriv_singleton] + · rw [show (μ ::ₘ s.erase ν : Multiset (Fin 1 ⊕ Fin 3)) = s.erase ν + {μ} from by + rw [add_comm, Multiset.singleton_add], + iteratedDeriv_add, LinearMap.comp_apply, iteratedDeriv_singleton] + have herase : ∀ ν ∈ s, (μ ::ₘ s).erase ν = μ ::ₘ s.erase ν := by + intro ν hν + rcases eq_or_ne ν μ with rfl | hne + · rw [Multiset.erase_cons_head, Multiset.cons_erase hν] + · rw [Multiset.erase_cons_tail _ hne.symm] + rw [symmetrizedMaurerCartanForm, Multiset.map_cons, Multiset.sum_cons, + Multiset.card_cons, Multiset.sub_singleton, Multiset.erase_cons_head, + Multiset.map_congr rfl fun ν hν => by rw [Multiset.sub_singleton, herase ν hν], + Multiset.map_congr rfl hswap, Multiset.sum_map_sub, Multiset.map_const', + Multiset.sum_replicate, ← Nat.cast_smul_eq_nsmul ℝ] + push_cast + match_scalars <;> field_simp <;> ring + + +/-- The `su(3)`-entry of the evaluated symmetrized Maurer–Cartan form, as a sum of + base-point values of iterated derivatives of the Maurer–Cartan form entries. -/ +lemma eval_symmetrizedMaurerCartanForm_toSU3_apply (U : JetGaugeGroupI) + (r : Multiset (Fin 1 ⊕ Fin 3)) (i j : Fin 3) : + (eval (symmetrizedMaurerCartanForm U r)).toSU3Matrix i j = + (1/(r.card : ℝ)) • (r.map fun μ => constantCoeff ((r.erase μ).foldl + (fun f ρ => pderiv ℂ ρ f) ((maurerCartanForm U μ).toSU3Matrix i j))).sum := by + set Φ : JetGaugeAlgebra →+ ℂ := AddMonoidHom.mk' + (fun a => (eval a).toSU3Matrix i j) + (fun a b => by simp [map_add, GaugeAlgebra.add_toSU3Matrix]) with hΦ + have hΦiter : ∀ μ ∈ r, Φ (iteratedDeriv (r - {μ}) (maurerCartanForm U μ)) = + constantCoeff ((r.erase μ).foldl (fun f ρ => pderiv ℂ ρ f) + ((maurerCartanForm U μ).toSU3Matrix i j)) := by + intro μ hμ + show (eval (iteratedDeriv (r - {μ}) (maurerCartanForm U μ))).toSU3Matrix i j = _ + rw [eval_toSU3Matrix_apply, iteratedDeriv_toSU3Matrix, Matrix.map_apply, + Multiset.sub_singleton] + rw [symmetrizedMaurerCartanForm, map_smul, GaugeAlgebra.smul_toSU3Matrix, + Matrix.smul_apply] + congr 1 + rw [show (eval ((r.map fun μ => + iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum)).toSU3Matrix i j + = Φ ((r.map fun μ => iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum) from rfl, + map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun μ hμ => hΦiter μ hμ) + +/-- The `su(2)`-entry of the evaluated symmetrized Maurer–Cartan form. -/ +lemma eval_symmetrizedMaurerCartanForm_toSU2_apply (U : JetGaugeGroupI) + (r : Multiset (Fin 1 ⊕ Fin 3)) (i j : Fin 2) : + (eval (symmetrizedMaurerCartanForm U r)).toSU2Matrix i j = + (1/(r.card : ℝ)) • (r.map fun μ => constantCoeff ((r.erase μ).foldl + (fun f ρ => pderiv ℂ ρ f) ((maurerCartanForm U μ).toSU2Matrix i j))).sum := by + set Φ : JetGaugeAlgebra →+ ℂ := AddMonoidHom.mk' + (fun a => (eval a).toSU2Matrix i j) + (fun a b => by simp [map_add, GaugeAlgebra.add_toSU2Matrix]) with hΦ + have hΦiter : ∀ μ ∈ r, Φ (iteratedDeriv (r - {μ}) (maurerCartanForm U μ)) = + constantCoeff ((r.erase μ).foldl (fun f ρ => pderiv ℂ ρ f) + ((maurerCartanForm U μ).toSU2Matrix i j)) := by + intro μ hμ + show (eval (iteratedDeriv (r - {μ}) (maurerCartanForm U μ))).toSU2Matrix i j = _ + rw [eval_toSU2Matrix_apply, iteratedDeriv_toSU2Matrix, Matrix.map_apply, + Multiset.sub_singleton] + rw [symmetrizedMaurerCartanForm, map_smul, GaugeAlgebra.smul_toSU2Matrix, + Matrix.smul_apply] + congr 1 + rw [show (eval ((r.map fun μ => + iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum)).toSU2Matrix i j + = Φ ((r.map fun μ => iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum) from rfl, + map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun μ hμ => hΦiter μ hμ) + +/-- The `u(1)`-value of the evaluated symmetrized Maurer–Cartan form. -/ +lemma eval_symmetrizedMaurerCartanForm_toU1Value (U : JetGaugeGroupI) + (r : Multiset (Fin 1 ⊕ Fin 3)) : + (eval (symmetrizedMaurerCartanForm U r)).toU1Value = + (1/(r.card : ℝ)) • (r.map fun μ => constantCoeff ((r.erase μ).foldl + (fun f ρ => pderiv ℂ ρ f) ((maurerCartanForm U μ).toU1Value))).sum := by + set Φ : JetGaugeAlgebra →+ ℂ := AddMonoidHom.mk' + (fun a => (eval a).toU1Value) + (fun a b => by simp [map_add, GaugeAlgebra.add_toU1Value]) with hΦ + have hΦiter : ∀ μ ∈ r, Φ (iteratedDeriv (r - {μ}) (maurerCartanForm U μ)) = + constantCoeff ((r.erase μ).foldl (fun f ρ => pderiv ℂ ρ f) + ((maurerCartanForm U μ).toU1Value)) := by + intro μ hμ + show (eval (iteratedDeriv (r - {μ}) (maurerCartanForm U μ))).toU1Value = _ + rw [eval_toU1Value_eq, iteratedDeriv_toU1Value, Multiset.sub_singleton] + rw [symmetrizedMaurerCartanForm, map_smul, GaugeAlgebra.smul_toU1Value] + congr 1 + rw [show (eval ((r.map fun μ => + iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum)).toU1Value + = Φ ((r.map fun μ => iteratedDeriv (r - {μ}) (maurerCartanForm U μ)).sum) from rfl, + map_multiset_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun μ hμ => hΦiter μ hμ) +/-- Determination step: if the base-point symmetrized Maurer–Cartan data of `U` and + `V` agree, and their Maurer–Cartan Taylor data agree in fewer than `n` directions, + then they agree in `n` directions. -/ +lemma eval_iteratedDeriv_maurerCartanForm_eq_of_symmetrized_eq (U V : JetGaugeGroupI) (n : ℕ) + (hsym : ∀ r, eval (symmetrizedMaurerCartanForm U r) = + eval (symmetrizedMaurerCartanForm V r)) + (ih : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), s.card < n → + eval (iteratedDeriv s (maurerCartanForm U μ)) = + eval (iteratedDeriv s (maurerCartanForm V μ))) + (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (hs : s.card = n) : + eval (iteratedDeriv s (maurerCartanForm U μ)) = + eval (iteratedDeriv s (maurerCartanForm V μ)) := by + rw [iteratedDeriv_maurerCartanForm_eq_symmetrized_add U s μ, + iteratedDeriv_maurerCartanForm_eq_symmetrized_add V s μ, + map_add, map_add, map_smul, map_smul, hsym] + refine congrArg (fun z => eval (symmetrizedMaurerCartanForm V (μ ::ₘ s)) + + (1/(s.card + 1 : ℝ)) • z) ?_ + rw [map_multiset_sum, map_multiset_sum, Multiset.map_map, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun ν hν => ?_) + have hlt : ∀ p : Multiset (Fin 1 ⊕ Fin 3), p ≤ s.erase ν → p.card < n := by + intro p hp + have h1 := Multiset.card_le_card hp + have h2 := Multiset.card_erase_add_one hν + omega + exact eval_iteratedDeriv_bracket_congr (s.erase ν) _ _ _ _ + (fun p hp => ih p μ (hlt p hp)) (fun p hp => ih p ν (hlt p hp)) + +/-! + +## The derivative of the adjoint action + +-/ + +/-- The constant inclusion has vanishing formal derivative: constants have no + spacetime dependence. -/ +@[simp] +lemma JetGaugeAlgebra.deriv_ofConstant (μ : Fin 1 ⊕ Fin 3) (a : GaugeAlgebra) : + deriv μ (ofConstant a) = 0 := by + ext <;> simp [Matrix.map_apply, pderiv_C] + +/-- The formal derivative intertwines the adjoint action through the Maurer–Cartan + form: `∂_μ (Ad_U x) = Ad_U (∂_μ x) − ⁅ω_μ(U), Ad_U x⁆`. On the matrix factors this + is the Leibniz rule with the derivative of `U†` rewritten through the + differentiated unitarity relation; on the abelian `u(1)` factor the adjoint action + is trivial and the bracket is absent. -/ +lemma deriv_adjointMap (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) (x : JetGaugeAlgebra) : + deriv μ (adjointMap U x) = + adjointMap U (deriv μ x) - ⁅maurerCartanForm U μ, adjointMap U x⁆ := by + have hleib : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (M N : Matrix κ κ JetRing), + (M * N).map (pderiv ℂ μ) = M.map (pderiv ℂ μ) * N + M * N.map (pderiv ℂ μ) := by + intro κ _ _ M N + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + have key : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] (V X : Matrix κ κ JetRing), + V * star V = 1 → + (V * X * star V).map (pderiv ℂ μ) = + V * X.map (pderiv ℂ μ) * star V - + Complex.I • (Complex.I • (V.map (pderiv ℂ μ) * star V) * (V * X * star V) - + (V * X * star V) * (Complex.I • (V.map (pderiv ℂ μ) * star V))) := by + intro κ _ _ V X hV + have hVV : star V * V = 1 := mul_eq_one_comm.mp hV + have hq : (star V).map (pderiv ℂ μ) = -(star V * V.map (pderiv ℂ μ) * star V) := by + have h1 : V * (star V).map (pderiv ℂ μ) = -(V.map (pderiv ℂ μ) * star V) := + eq_neg_of_add_eq_zero_right (by + rw [← hleib _ V (star V), hV] + exact Matrix.ext fun i j => by + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ μ)]) + calc (star V).map (pderiv ℂ μ) + = star V * V * (star V).map (pderiv ℂ μ) := by rw [hVV, one_mul] + _ = -(star V * V.map (pderiv ℂ μ) * star V) := by + rw [mul_assoc, h1, mul_neg, ← mul_assoc] + rw [hleib _ (V * X) (star V), hleib _ V X, hq] + simp only [smul_mul_assoc, mul_smul_comm, ← smul_sub, smul_smul, Complex.I_mul_I, + neg_one_smul, sub_neg_eq_add, add_mul, mul_neg, ← mul_assoc] + rw [mul_assoc (V.map (pderiv ℂ μ)) (star V) V, hVV, mul_one] + abel + refine ext_of_matrix ?_ ?_ ?_ + · simpa only [deriv_toSU3Matrix, adjointMap_toSU3Matrix, sub_toSU3Matrix, + bracket_toSU3Matrix, maurerCartanForm_toSU3Matrix] using + key _ U.1.1 x.toSU3Matrix (Matrix.mem_unitaryGroup_iff.mp + (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1) + · simpa only [deriv_toSU2Matrix, adjointMap_toSU2Matrix, sub_toSU2Matrix, + bracket_toSU2Matrix, maurerCartanForm_toSU2Matrix] using + key _ U.2.1.1 x.toSU2Matrix (Matrix.mem_unitaryGroup_iff.mp + (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1) + · simp + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean new file mode 100644 index 000000000..09500ce38 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean @@ -0,0 +1,565 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.MaurerCartan.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Truncation +public import Physlib.Particles.StandardModel.GaugeAlgebra.JetGaugeAlgebra +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Basic +public import Physlib.Relativity.Tensors.RealTensor.Vector.Representation +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Physlib.Particles.LagrangianTheory.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.MvPolynomialTranslation +public import Mathlib.Algebra.MvPolynomial.Derivation +/-! +# The Maurer–Cartan forms and the truncation kernels +-/ + +@[expose] public section +namespace StandardModel +open MvPowerSeries JetGaugeAlgebra JetRing +/-- Projecting onto the zeroth truncation kernel does not change the Maurer–Cartan + form: by the cocycle law, right-multiplication by a constant gauge transformation + drops out. -/ +lemma maurerCartanForm_truncationProjZero (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + maurerCartanForm (JetGaugeGroupI.truncationProjZero U : JetGaugeGroupI) μ = + maurerCartanForm U μ := by + rw [show (JetGaugeGroupI.truncationProjZero U : JetGaugeGroupI) = + U * (JetGaugeGroupI.ofConstant U.eval)⁻¹ from rfl, + ← map_inv, maurerCartanForm_cocycle, maurerCartanForm_ofConstant] + simp + +/-- A pure jet is determined by its Maurer–Cartan form: on the kernel of the zeroth + truncation, `U ↦ ω(U)` is injective. By the cocycle and inverse laws + `ω(V⁻¹ U) = Ad_{V⁻¹}(ω(U) − ω(V)) = 0`, so `V⁻¹ U` is a constant jet, and purity + of `U` and `V` forces that constant to be the identity. -/ +lemma maurerCartanForm_injOn_truncationKer_zero {U V : JetGaugeGroupI} + (hU : U ∈ JetGaugeGroupI.truncationKer 0) (hV : V ∈ JetGaugeGroupI.truncationKer 0) + (h : maurerCartanForm U = maurerCartanForm V) : U = V := by + have h1 : maurerCartanForm (V⁻¹ * U) = 0 := by + funext μ + rw [maurerCartanForm_cocycle, maurerCartanForm_inv, congrFun h μ] + simp + obtain ⟨c, hc⟩ := (maurerCartanForm_eq_zero_iff_ofConstant _).mp h1 + have hc1 : c = 1 := by + have he := congrArg JetGaugeGroupI.eval hc + rw [map_mul, map_inv, JetGaugeGroupI.mem_truncationKer_zero_iff.mp hU, + JetGaugeGroupI.mem_truncationKer_zero_iff.mp hV, JetGaugeGroupI.eval_ofConstant] at he + simpa using he.symm + rw [hc1, map_one] at hc + exact (inv_mul_eq_one.mp hc).symm + +lemma exists_maurerCartanForm_eq_of_structure + (ω : (Fin 1 ⊕ Fin 3) → JetGaugeAlgebra) + (hω : ∀ μ ν, deriv μ (ω ν) - deriv ν (ω μ) + ⁅ω μ, ω ν⁆ = 0) : + ∃ U ∈ JetGaugeGroupI.truncationKer 0, maurerCartanForm U = ω := by + obtain ⟨U, hU0, hU⟩ := exists_deriv_eq_of_maurerCartanForm_structure ω hω + refine ⟨U, JetGaugeGroupI.mem_truncationKer_zero_iff.mpr hU0, funext fun μ => ?_⟩ + have hu3 : U.1.1 * star U.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hu2 : U.2.1.1 * star U.2.1.1 = 1 := by + have h := (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff] at h + have hu1 : U.2.2.1 * star U.2.2.1 = 1 := (Unitary.mem_iff.mp U.2.2.2).2 + refine ext_of_matrix ?_ ?_ ?_ + · rw [maurerCartanForm_toSU3Matrix, + show U.1.1.map (pderiv ℂ μ) = (-Complex.I) • (ω μ).toSU3Matrix * U.1.1 from + congrArg (fun p => p.1) (hU μ), + smul_mul_assoc, smul_mul_assoc, mul_assoc, hu3, mul_one, smul_smul] + simp + · rw [maurerCartanForm_toSU2Matrix, + show U.2.1.1.map (pderiv ℂ μ) = (-Complex.I) • (ω μ).toSU2Matrix * U.2.1.1 from + congrArg (fun p => p.2.1) (hU μ), + smul_mul_assoc, smul_mul_assoc, mul_assoc, hu2, mul_one, smul_smul] + simp + · rw [maurerCartanForm_toU1Value, + show pderiv ℂ μ U.2.2.1 = (-Complex.I) • (ω μ).toU1Value * U.2.2.1 from + congrArg (fun p => p.2.2) (hU μ), + smul_mul_assoc, smul_mul_assoc, mul_assoc, hu1, mul_one, smul_smul] + simp + + +/-! + +## Freeness: injectivity of the symmetrized Maurer–Cartan data + +-/ + +/-- The symmetrized Maurer–Cartan data of a pure jet: the base-point values of its + symmetrized Maurer–Cartan forms, indexed by nonempty multisets of directions. + Total symmetry is automatic from the multiset indexing. -/ +noncomputable def symmetrizedMaurerCartanCoeff (U : JetGaugeGroupI.truncationKer 0) + (r : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) : GaugeAlgebra := + eval (symmetrizedMaurerCartanForm U.1 r.1) + +/-- Freeness, injectivity half: a pure jet is determined by its symmetrized + Maurer–Cartan data. The symmetrized data determine all Maurer–Cartan Taylor data + by strong induction with `eval_iteratedDeriv_maurerCartanForm_eq_of_symmetrized_eq`, + hence the Maurer–Cartan form itself by Taylor determinacy, hence the pure jet by + `maurerCartanForm_injOn_truncationKer_zero`. -/ +lemma symmetrizedMaurerCartanCoeff_injective : Function.Injective symmetrizedMaurerCartanCoeff := by + intro U V h + -- the hypothesis extends to all multisets, the empty one trivially + have hsym : ∀ r, eval (symmetrizedMaurerCartanForm U.1 r) = + eval (symmetrizedMaurerCartanForm V.1 r) := by + intro r + by_cases hr : r = 0 + · subst hr + simp + · exact congrFun h ⟨r, hr⟩ + -- all Maurer–Cartan Taylor data agree, by strong induction on the number of directions + have hall : ∀ (n : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), s.card = n → + eval (iteratedDeriv s (maurerCartanForm U.1 μ)) = + eval (iteratedDeriv s (maurerCartanForm V.1 μ)) := by + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro s μ hs + exact eval_iteratedDeriv_maurerCartanForm_eq_of_symmetrized_eq U.1 V.1 n hsym + (fun p ν hp => ih p.card hp p ν rfl) s μ hs + -- hence the Maurer–Cartan forms agree, by Taylor determinacy + have hmc : maurerCartanForm U.1 = maurerCartanForm V.1 := by + funext μ + exact ext_of_eval_iteratedDeriv fun s => hall s.card s μ rfl + exact Subtype.ext (maurerCartanForm_injOn_truncationKer_zero U.2 V.2 hmc) + +TODO "The below code needs cleaning up and moving to the correct place." +/-! + +## The symmetrized data through the radial Maurer–Cartan component + +-/ + +lemma symmetrizedMaurerCartanCoeff_apply (U : JetGaugeGroupI.truncationKer 0) + (x : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0}) : + symmetrizedMaurerCartanCoeff U x = eval (symmetrizedMaurerCartanForm U.1 x.1) := rfl + +lemma symmetrizedMaurerCartanCoeff_toSU3_eq (U : JetGaugeGroupI.truncationKer 0) + (P : Matrix (Fin 3) (Fin 3) JetRing) + (hrad : ∑ μ, (X μ : JetRing) • (maurerCartanForm U.1 μ).toSU3Matrix = P) + (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0) (i j : Fin 3) : + (symmetrizedMaurerCartanCoeff U ⟨r, hr⟩).toSU3Matrix i j = + (1/(Multiset.card r : ℝ)) • (((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ) * + coeff (Multiset.toFinsupp r) (P i j)) := by + have hentry : (∑ μ, (X μ : JetRing) • ((maurerCartanForm U.1 μ).toSU3Matrix i j)) = + P i j := by + have h1 : (∑ μ, (X μ : JetRing) • ((maurerCartanForm U.1 μ).toSU3Matrix i j)) = + (∑ μ, (X μ : JetRing) • (maurerCartanForm U.1 μ).toSU3Matrix) i j := by + rw [Matrix.sum_apply] + exact Finset.sum_congr rfl fun μ _ => rfl + rw [h1, hrad] + rw [symmetrizedMaurerCartanCoeff_apply, eval_symmetrizedMaurerCartanForm_toSU3_apply, + sum_constantCoeff_foldl_erase, hentry] + +lemma symmetrizedMaurerCartanCoeff_toSU2_eq (U : JetGaugeGroupI.truncationKer 0) + (P : Matrix (Fin 2) (Fin 2) JetRing) + (hrad : ∑ μ, (X μ : JetRing) • (maurerCartanForm U.1 μ).toSU2Matrix = P) + (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0) (i j : Fin 2) : + (symmetrizedMaurerCartanCoeff U ⟨r, hr⟩).toSU2Matrix i j = + (1/(Multiset.card r : ℝ)) • (((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ) * + coeff (Multiset.toFinsupp r) (P i j)) := by + have hentry : (∑ μ, (X μ : JetRing) • ((maurerCartanForm U.1 μ).toSU2Matrix i j)) = + P i j := by + have h1 : (∑ μ, (X μ : JetRing) • ((maurerCartanForm U.1 μ).toSU2Matrix i j)) = + (∑ μ, (X μ : JetRing) • (maurerCartanForm U.1 μ).toSU2Matrix) i j := by + rw [Matrix.sum_apply] + exact Finset.sum_congr rfl fun μ _ => rfl + rw [h1, hrad] + rw [symmetrizedMaurerCartanCoeff_apply, eval_symmetrizedMaurerCartanForm_toSU2_apply, + sum_constantCoeff_foldl_erase, hentry] + +lemma symmetrizedMaurerCartanCoeff_toU1_eq (U : JetGaugeGroupI.truncationKer 0) + (p : JetRing) + (hrad : ∑ μ, (X μ : JetRing) • (maurerCartanForm U.1 μ).toU1Value = p) + (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0) : + (symmetrizedMaurerCartanCoeff U ⟨r, hr⟩).toU1Value = + (1/(Multiset.card r : ℝ)) • (((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ) * + coeff (Multiset.toFinsupp r) p) := by + rw [symmetrizedMaurerCartanCoeff_apply, eval_symmetrizedMaurerCartanForm_toU1Value, + sum_constantCoeff_foldl_erase, hrad] + +/-! + +## Freeness: surjectivity of the symmetrized Maurer–Cartan data + +-/ + +/-- Freeness, surjectivity half: every prescribed family of symmetrized Maurer–Cartan + data is realized by a pure jet. The radial component `ρ := ∑ μ x_μ ω_μ` of the + Maurer–Cartan form carries exactly the symmetrized data, so it suffices to solve the + radial (Euler) system `E U = −i ρ U`, `U(0) = 1` for a prescribed `ρ`; this is done + factorwise by `exists_matrix_eulerTransport`, with unitarity and determinant one from + the Euler vanishing principle. -/ +lemma symmetrizedMaurerCartanCoeff_surjective : + Function.Surjective symmetrizedMaurerCartanCoeff := by + classical + intro c + -- the factorwise construction: a unitary Euler transport with prescribed radial data + have hcore : ∀ (κ : Type) [Fintype κ] [DecidableEq κ] + (E : {r : Multiset (Fin 1 ⊕ Fin 3) // r ≠ 0} → Matrix κ κ ℂ), + (∀ x, star (E x) = E x) → + ∃ V P : Matrix κ κ JetRing, + (constantCoeff : JetRing →+* ℂ).mapMatrix V = 1 ∧ + V * star V = 1 ∧ + (∑ μ, (X μ : JetRing) • (Complex.I • (V.map (pderiv ℂ μ) * star V)) = P) ∧ + ((∀ x, (E x).trace = 0) → + (∀ (M : Matrix κ κ JetRing) (μ : Fin 1 ⊕ Fin 3), + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace) → V.det = 1) ∧ + (∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0) (i j : κ), + coeff (Multiset.toFinsupp r) (P i j) = + (((Multiset.card r : ℕ) : ℂ) / + ((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ)) * E ⟨r, hr⟩ i j) := by + intro κ _ _ E hEstar + set P : Matrix κ κ JetRing := Matrix.of fun i j => + show JetRing from fun m => + if h : Finsupp.toMultiset m = 0 then 0 + else (((Finsupp.degree m : ℕ) : ℂ) / ((∏ ν, Nat.factorial (m ν) : ℕ) : ℂ)) * + E ⟨Finsupp.toMultiset m, h⟩ i j with hP + have hPcoeff : ∀ (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) (i j : κ), coeff m (P i j) = + if h : Finsupp.toMultiset m = 0 then 0 + else (((Finsupp.degree m : ℕ) : ℂ) / ((∏ ν, Nat.factorial (m ν) : ℕ) : ℂ)) * + E ⟨Finsupp.toMultiset m, h⟩ i j := fun _ _ _ => rfl + have hP0 : ∀ i j, constantCoeff (P i j) = 0 := fun i j => by + rw [← coeff_zero_eq_constantCoeff, hPcoeff, dif_pos (by simp)] + have hPstar : star P = P := by + ext i j : 1 + ext m + rw [Matrix.star_apply, JetRing.coeff_star, hPcoeff, hPcoeff] + split_ifs with h + · simp + · rw [star_mul', show star (E ⟨Finsupp.toMultiset m, h⟩ j i) + = E ⟨Finsupp.toMultiset m, h⟩ i j from by + conv_rhs => rw [← hEstar ⟨Finsupp.toMultiset m, h⟩] + exact (Matrix.star_apply _ _ _).symm, + star_div₀, star_natCast, star_natCast] + have hR0 : ∀ i j, constantCoeff (((-Complex.I) • P) i j) = 0 := fun i j => by + rw [Matrix.smul_apply, ← coeff_zero_eq_constantCoeff, map_smul, + coeff_zero_eq_constantCoeff, hP0, smul_zero] + have hRstar : star ((-Complex.I) • P) = -((-Complex.I) • P) := by + rw [star_smul, hPstar] + simp + obtain ⟨V, hV0, hEV⟩ := exists_matrix_eulerTransport ((-Complex.I) • P) hR0 + have hVu : V * star V = 1 := eulerTransport_mul_star hRstar hR0 hV0 hEV + refine ⟨V, P, hV0, hVu, ?_, ?_, ?_⟩ + · calc ∑ μ, (X μ : JetRing) • (Complex.I • (V.map (pderiv ℂ μ) * star V)) + = Complex.I • ((∑ μ, (X μ : JetRing) • V.map (pderiv ℂ μ)) * star V) := by + rw [Finset.sum_mul, Finset.smul_sum] + exact Finset.sum_congr rfl fun μ _ => by + rw [Matrix.smul_mul, smul_comm Complex.I] + _ = P := by + rw [hEV, Matrix.smul_mul, Matrix.smul_mul, Matrix.mul_assoc, hVu, mul_one, + smul_smul] + simp + · intro hEtr hjac + have hPtr : P.trace = 0 := by + ext m + rw [show coeff m P.trace = ∑ i, coeff m (P i i) from by + rw [show P.trace = ∑ i, P i i from rfl, map_sum], + map_zero, Finset.sum_congr rfl fun i _ => hPcoeff m i i] + by_cases h : Finsupp.toMultiset m = 0 + · simp [h] + · simp only [dif_neg h] + rw [← Finset.mul_sum, + show (∑ i, E ⟨Finsupp.toMultiset m, h⟩ i i) = (E ⟨Finsupp.toMultiset m, h⟩).trace + from rfl, + hEtr, mul_zero] + have hRtr : ((-Complex.I) • P).trace = 0 := by + rw [Matrix.trace_smul, hPtr, smul_zero] + exact eulerTransport_det hjac hRtr hV0 hEV + · intro r hr i j + have hround : Finsupp.toMultiset (Multiset.toFinsupp r) = r := by simp + rw [hPcoeff, dif_neg (show ¬Finsupp.toMultiset (Multiset.toFinsupp r) = 0 from by + rw [hround]; exact hr), + show (∏ ν, Nat.factorial ((Multiset.toFinsupp r) ν)) = ∏ ν, Nat.factorial (r.count ν) + from Finset.prod_congr rfl fun ν _ => by rw [Multiset.toFinsupp_apply], + degree_toFinsupp_eq_card] + exact congrArg (fun x => (((Multiset.card r : ℕ) : ℂ) / + ((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ)) * E x i j) (Subtype.ext hround) + -- apply the construction on each factor + obtain ⟨V₃, P₃, hV₃0, hV₃u, hrad₃, hdet₃, hcoeff₃⟩ := + hcore (Fin 3) (fun x => (c x).toSU3Matrix) + (fun x => show star (c x).toSU3Matrix = (c x).toSU3Matrix from (c x).1.2.1) + obtain ⟨V₂, P₂, hV₂0, hV₂u, hrad₂, hdet₂, hcoeff₂⟩ := + hcore (Fin 2) (fun x => (c x).toSU2Matrix) + (fun x => show star (c x).toSU2Matrix = (c x).toSU2Matrix from (c x).2.1.2.1) + obtain ⟨V₁, P₁, hV₁0, hV₁u, hrad₁, _, hcoeff₁⟩ := + hcore (Fin 1) (fun x => Matrix.of fun _ _ => (c x).toU1Value) + (fun x => Matrix.ext fun _ _ => (c x).2.2.2) + have hd₃ : V₃.det = 1 := hdet₃ + (fun x => show ((c x).toSU3Matrix).trace = 0 from (c x).1.2.2) jacobi_fin3 + have hd₂ : V₂.det = 1 := hdet₂ + (fun x => show ((c x).toSU2Matrix).trace = 0 from (c x).2.1.2.2) jacobi_fin2 + have hu1 : V₁ 0 0 * star (V₁ 0 0) = 1 := by + simpa [Matrix.mul_apply] using congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) hV₁u + have hu0 : constantCoeff (V₁ 0 0) = 1 := by + simpa using congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) hV₁0 + -- the scalar radial identity for the `U(1)` factor + have hrad₁' : ∑ μ, (X μ : JetRing) • + (Complex.I • (pderiv ℂ μ (V₁ 0 0) * star (V₁ 0 0))) = P₁ 0 0 := by + have h := congrArg (fun M => M (0 : Fin 1) (0 : Fin 1)) hrad₁ + simpa [Matrix.sum_apply, Matrix.mul_apply] using h + refine ⟨⟨(⟨V₃, Matrix.mem_specialUnitaryGroup_iff.mpr + ⟨Matrix.mem_unitaryGroup_iff.mpr hV₃u, hd₃⟩⟩, + ⟨V₂, Matrix.mem_specialUnitaryGroup_iff.mpr + ⟨Matrix.mem_unitaryGroup_iff.mpr hV₂u, hd₂⟩⟩, + ⟨V₁ 0 0, Unitary.mem_iff.mpr ⟨by rw [mul_comm]; exact hu1, hu1⟩⟩), + JetGaugeGroupI.mem_truncationKer_zero_iff.mpr + (Prod.ext (Subtype.ext hV₃0) (Prod.ext (Subtype.ext hV₂0) (Subtype.ext hu0)))⟩, ?_⟩ + funext x + obtain ⟨r, hr⟩ := x + have hcard : ((Multiset.card r : ℕ) : ℂ) ≠ 0 := + Nat.cast_ne_zero.mpr fun hc => hr (Multiset.card_eq_zero.mp hc) + have hfacne : ((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ) ≠ 0 := + Nat.cast_ne_zero.mpr (Finset.prod_ne_zero_iff.mpr fun ν _ => Nat.factorial_ne_zero _) + have hfacne' : (∏ ν, ((Nat.factorial (r.count ν) : ℕ) : ℂ)) ≠ 0 := + Finset.prod_ne_zero_iff.mpr fun ν _ => Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero _) + refine GaugeAlgebra.ext_of_matrix ?_ ?_ ?_ + · ext i j : 1 + rw [symmetrizedMaurerCartanCoeff_toSU3_eq _ P₃ + (by simp only [maurerCartanForm_toSU3Matrix]; exact hrad₃) r hr i j, + hcoeff₃ r hr i j, Complex.real_smul] + push_cast + field_simp + · ext i j : 1 + rw [symmetrizedMaurerCartanCoeff_toSU2_eq _ P₂ + (by simp only [maurerCartanForm_toSU2Matrix]; exact hrad₂) r hr i j, + hcoeff₂ r hr i j, Complex.real_smul] + push_cast + field_simp + · rw [symmetrizedMaurerCartanCoeff_toU1_eq _ (P₁ 0 0) + (by simp only [maurerCartanForm_toU1Value]; exact hrad₁') r hr, + hcoeff₁ r hr 0 0, Complex.real_smul, Matrix.of_apply] + push_cast + field_simp + + +/-- **Maurer–Cartan triangularity**: a pure jet whose symmetrized Maurer–Cartan + coefficients vanish up to order `n` lies in the `n`-th truncation kernel. -/ +lemma mem_truncationKer_of_symmetrizedMaurerCartanCoeff_eq_zero + (U : JetGaugeGroupI.truncationKer 0) (n : ℕ) + (h : ∀ (r : Multiset (Fin 1 ⊕ Fin 3)) (hr : r ≠ 0), r.card ≤ n → + symmetrizedMaurerCartanCoeff U ⟨r, hr⟩ = 0) : + U.1 ∈ JetGaugeGroupI.truncationKer n := by + classical + -- Step 1: the base-point Maurer–Cartan Taylor data vanish below order `n`, by + -- strong induction with the symmetrization defect formula. + have hall : ∀ (k : ℕ) (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), + s.card = k → k < n → eval (iteratedDeriv s (maurerCartanForm U.1 μ)) = 0 := by + intro k + induction k using Nat.strong_induction_on with + | _ k ih => + intro s μ hs hk + rw [iteratedDeriv_maurerCartanForm_eq_symmetrized_add U.1 s μ, map_add, map_smul] + have h1 : eval (symmetrizedMaurerCartanForm U.1 (μ ::ₘ s)) = 0 := by + have hle : (μ ::ₘ s).card ≤ n := by rw [Multiset.card_cons, hs]; omega + have h2 := h (μ ::ₘ s) (Multiset.cons_ne_zero) hle + rwa [symmetrizedMaurerCartanCoeff_apply] at h2 + have h2 : eval ((s.map fun ν => iteratedDeriv (s.erase ν) + ⁅maurerCartanForm U.1 μ, maurerCartanForm U.1 ν⁆).sum) = 0 := by + rw [map_multiset_sum, Multiset.map_map] + refine Multiset.sum_eq_zero fun x hx => ?_ + obtain ⟨ν, hν, rfl⟩ := Multiset.mem_map.mp hx + have hzero : ∀ (ρ : Fin 1 ⊕ Fin 3) (p : Multiset (Fin 1 ⊕ Fin 3)), + p ≤ s.erase ν → eval (iteratedDeriv p (maurerCartanForm U.1 ρ)) = + eval (iteratedDeriv p (0 : JetGaugeAlgebra)) := by + intro ρ p hp + have hcard : p.card < k := by + have h3 := Multiset.card_le_card hp + have h4 := Multiset.card_erase_add_one hν + omega + rw [ih p.card hcard p ρ rfl (hcard.trans hk), map_zero, map_zero] + simp only [Function.comp_apply] + rw [eval_iteratedDeriv_bracket_congr (s.erase ν) _ _ 0 0 (hzero μ) (hzero ν)] + simp + rw [h1, h2] + simp + -- Step 2: the Taylor coefficients of the Maurer–Cartan form components vanish in + -- all degrees below `n`. + have hfac : ∀ s : Multiset (Fin 1 ⊕ Fin 3), + ((∏ ν, Nat.factorial (s.count ν) : ℕ) : ℂ) ≠ 0 := fun s => + Nat.cast_ne_zero.mpr (Finset.prod_ne_zero_iff.mpr fun ν _ => Nat.factorial_ne_zero _) + have hround : ∀ m : (Fin 1 ⊕ Fin 3) →₀ ℕ, + Multiset.toFinsupp (Finsupp.toMultiset m) = m := fun m => by simp + have hcardm : ∀ m : (Fin 1 ⊕ Fin 3) →₀ ℕ, + (Finsupp.toMultiset m).card = Finsupp.degree m := fun m => by + rw [← degree_toFinsupp_eq_card, hround] + have hω3 : ∀ (ρ : Fin 1 ⊕ Fin 3) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree m < n → + ∀ i j, coeff m ((maurerCartanForm U.1 ρ).toSU3Matrix i j) = 0 := by + intro ρ m hm i j + have h0 := hall (Finsupp.toMultiset m).card (Finsupp.toMultiset m) ρ rfl + (by rw [hcardm m]; exact hm) + have h1 := congrArg (fun a => GaugeAlgebra.toSU3Matrix a i j) h0 + simp only [GaugeAlgebra.zero_toSU3Matrix, Matrix.zero_apply] at h1 + rw [eval_toSU3Matrix_apply, iteratedDeriv_toSU3Matrix, Matrix.map_apply, + constantCoeff_foldl_pderiv, hround] at h1 + exact (mul_eq_zero.mp h1).resolve_left (hfac _) + have hω2 : ∀ (ρ : Fin 1 ⊕ Fin 3) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree m < n → + ∀ i j, coeff m ((maurerCartanForm U.1 ρ).toSU2Matrix i j) = 0 := by + intro ρ m hm i j + have h0 := hall (Finsupp.toMultiset m).card (Finsupp.toMultiset m) ρ rfl + (by rw [hcardm m]; exact hm) + have h1 := congrArg (fun a => GaugeAlgebra.toSU2Matrix a i j) h0 + simp only [GaugeAlgebra.zero_toSU2Matrix, Matrix.zero_apply] at h1 + rw [eval_toSU2Matrix_apply, iteratedDeriv_toSU2Matrix, Matrix.map_apply, + constantCoeff_foldl_pderiv, hround] at h1 + exact (mul_eq_zero.mp h1).resolve_left (hfac _) + have hω1 : ∀ (ρ : Fin 1 ⊕ Fin 3) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree m < n → + coeff m ((maurerCartanForm U.1 ρ).toU1Value) = 0 := by + intro ρ m hm + have h0 := hall (Finsupp.toMultiset m).card (Finsupp.toMultiset m) ρ rfl + (by rw [hcardm m]; exact hm) + have h1 := congrArg GaugeAlgebra.toU1Value h0 + simp only [GaugeAlgebra.zero_toU1Value] at h1 + rw [eval_toU1Value_eq, iteratedDeriv_toU1Value, constantCoeff_foldl_pderiv, + hround] at h1 + exact (mul_eq_zero.mp h1).resolve_left (hfac _) + -- Step 3: the Euler operator toolkit. A product with a factor whose coefficients + -- vanish below degree `n` has vanishing coefficients below degree `n` ... + have hmul : ∀ (w v : JetRing), + (∀ q : (Fin 1 ⊕ Fin 3) →₀ ℕ, Finsupp.degree q < n → coeff q w = 0) → + ∀ q : (Fin 1 ⊕ Fin 3) →₀ ℕ, Finsupp.degree q < n → coeff q (w * v) = 0 := by + intro w v hw q hq + rw [coeff_mul] + refine Finset.sum_eq_zero fun p hp => ?_ + have hpq : p.1 + p.2 = q := Finset.mem_antidiagonal.mp hp + have hdeg : Finsupp.degree p.1 ≤ Finsupp.degree q := by + rw [← hpq, map_add] + exact Nat.le_add_right _ _ + rw [hw p.1 (lt_of_le_of_lt hdeg hq), zero_mul] + -- ... and a jet whose derivatives have vanishing coefficients below degree `n` has + -- vanishing coefficients in all nonzero degrees up to `n`, by the Euler identity. + have hvanish : ∀ f : JetRing, + (∀ (ρ : Fin 1 ⊕ Fin 3) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree q < n → + coeff q (pderiv ℂ ρ f) = 0) → + ∀ p : (Fin 1 ⊕ Fin 3) →₀ ℕ, p ≠ 0 → Finsupp.degree p ≤ n → coeff p f = 0 := by + intro f hf p hp hpn + have h1 := JetRing.coeff_sum_X_smul_pderiv f p + have h2 : coeff p (∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ f) = 0 := by + rw [map_sum] + refine Finset.sum_eq_zero fun ρ _ => ?_ + rw [JetRing.coeff_X_smul] + split_ifs with hle + · refine hf ρ _ ?_ + have hd := congrArg Finsupp.degree (tsub_add_cancel_of_le hle) + rw [map_add, Finsupp.degree_single] at hd + omega + · rfl + rw [h2] at h1 + have hne : ((Finsupp.degree p : ℕ) : ℂ) ≠ 0 := + Nat.cast_ne_zero.mpr fun hc => hp ((Finsupp.degree_eq_zero_iff p).mp hc) + exact (mul_eq_zero.mp h1.symm).resolve_left hne + -- the radial derivative relation `∂_μ U = (−i ω_μ) U` on each factor + have hstar3 : star U.1.1.1 * U.1.1.1 = 1 := by + have h1 := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h1 + have hstar2 : star U.1.2.1.1 * U.1.2.1.1 = 1 := by + have h1 := (Matrix.mem_specialUnitaryGroup_iff.mp U.1.2.1.2).1 + rwa [Matrix.mem_unitaryGroup_iff'] at h1 + have hstar1 : star U.1.2.2.1 * U.1.2.2.1 = 1 := (Unitary.mem_iff.mp U.1.2.2.2).1 + have hd3 : ∀ ρ, U.1.1.1.map (pderiv ℂ ρ) = + ((-Complex.I) • (maurerCartanForm U.1 ρ).toSU3Matrix) * U.1.1.1 := by + intro ρ + rw [maurerCartanForm_toSU3Matrix, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar3, mul_one] + have hd2 : ∀ ρ, U.1.2.1.1.map (pderiv ℂ ρ) = + ((-Complex.I) • (maurerCartanForm U.1 ρ).toSU2Matrix) * U.1.2.1.1 := by + intro ρ + rw [maurerCartanForm_toSU2Matrix, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar2, mul_one] + have hd1 : ∀ ρ, pderiv ℂ ρ U.1.2.2.1 = + ((-Complex.I) • (maurerCartanForm U.1 ρ).toU1Value) * U.1.2.2.1 := by + intro ρ + rw [maurerCartanForm_toU1Value, smul_smul, neg_mul, Complex.I_mul_I, neg_neg, + one_smul, mul_assoc, hstar1, mul_one] + -- coefficient vanishing for the entries of `U` in nonzero degree up to `n` + have hU3 : ∀ (i j : Fin 3) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), p ≠ 0 → + Finsupp.degree p ≤ n → coeff p (U.1.1.1 i j) = 0 := by + intro i j p hp hpn + refine hvanish _ (fun ρ q hq => ?_) p hp hpn + have h1 : pderiv ℂ ρ (U.1.1.1 i j) = + (((-Complex.I) • (maurerCartanForm U.1 ρ).toSU3Matrix) * U.1.1.1) i j := by + rw [← hd3 ρ, Matrix.map_apply] + rw [h1, Matrix.mul_apply, map_sum] + refine Finset.sum_eq_zero fun k _ => ?_ + refine hmul _ _ (fun q' hq' => ?_) q hq + rw [Matrix.smul_apply, map_smul, hω3 ρ q' hq' i k, smul_zero] + have hU2 : ∀ (i j : Fin 2) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), p ≠ 0 → + Finsupp.degree p ≤ n → coeff p (U.1.2.1.1 i j) = 0 := by + intro i j p hp hpn + refine hvanish _ (fun ρ q hq => ?_) p hp hpn + have h1 : pderiv ℂ ρ (U.1.2.1.1 i j) = + (((-Complex.I) • (maurerCartanForm U.1 ρ).toSU2Matrix) * U.1.2.1.1) i j := by + rw [← hd2 ρ, Matrix.map_apply] + rw [h1, Matrix.mul_apply, map_sum] + refine Finset.sum_eq_zero fun k _ => ?_ + refine hmul _ _ (fun q' hq' => ?_) q hq + rw [Matrix.smul_apply, map_smul, hω2 ρ q' hq' i k, smul_zero] + have hU1 : ∀ p : (Fin 1 ⊕ Fin 3) →₀ ℕ, p ≠ 0 → Finsupp.degree p ≤ n → + coeff p U.1.2.2.1 = 0 := by + intro p hp hpn + refine hvanish _ (fun ρ q hq => ?_) p hp hpn + rw [hd1 ρ] + refine hmul _ _ (fun q' hq' => ?_) q hq + rw [map_smul, hω1 ρ q' hq', smul_zero] + -- assemble: agreement with the identity jet in all degrees up to `n` + have heval : U.1.eval = 1 := JetGaugeGroupI.eval_coe_of_mem_truncationKer_zero U + rw [JetGaugeGroupI.mem_truncationKer_iff] + refine Prod.ext ?_ (Prod.ext ?_ ?_) + · show U.1.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 3) (Fin 3) JetRing).map (JetRing.truncation n) + ext i j : 1 + simp only [Matrix.map_apply] + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [JetRing.coeff_truncation_of_le hm, JetRing.coeff_truncation_of_le hm] + rcases eq_or_ne m 0 with rfl | hm0 + · have h3 := congrArg (fun p => (p.1 : Matrix (Fin 3) (Fin 3) ℂ) i j) heval + simpa [JetGaugeGroupI.eval, JetGaugeGroupI.evalSU, RingHom.mapMatrix_apply, + Matrix.map_apply, Matrix.one_apply, apply_ite constantCoeff, + coeff_zero_eq_constantCoeff] using h3 + · rw [hU3 i j m hm0 hm] + rcases eq_or_ne i j with rfl | hij + · rw [Matrix.one_apply_eq, coeff_one, if_neg hm0] + · rw [Matrix.one_apply_ne hij, map_zero] + · rw [JetRing.coeff_truncation_of_gt (not_le.mp hm), + JetRing.coeff_truncation_of_gt (not_le.mp hm)] + · show U.1.2.1.1.map (JetRing.truncation n) = + (1 : Matrix (Fin 2) (Fin 2) JetRing).map (JetRing.truncation n) + ext i j : 1 + simp only [Matrix.map_apply] + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [JetRing.coeff_truncation_of_le hm, JetRing.coeff_truncation_of_le hm] + rcases eq_or_ne m 0 with rfl | hm0 + · have h3 := congrArg (fun p => (p.2.1 : Matrix (Fin 2) (Fin 2) ℂ) i j) heval + simpa [JetGaugeGroupI.eval, JetGaugeGroupI.evalSU, RingHom.mapMatrix_apply, + Matrix.map_apply, Matrix.one_apply, apply_ite constantCoeff, + coeff_zero_eq_constantCoeff] using h3 + · rw [hU2 i j m hm0 hm] + rcases eq_or_ne i j with rfl | hij + · rw [Matrix.one_apply_eq, coeff_one, if_neg hm0] + · rw [Matrix.one_apply_ne hij, map_zero] + · rw [JetRing.coeff_truncation_of_gt (not_le.mp hm), + JetRing.coeff_truncation_of_gt (not_le.mp hm)] + · show JetRing.truncation n U.1.2.2.1 = JetRing.truncation n (1 : JetRing) + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [JetRing.coeff_truncation_of_le hm, JetRing.coeff_truncation_of_le hm] + rcases eq_or_ne m 0 with rfl | hm0 + · have h3 := congrArg (fun p => (p.2.2 : ℂ)) heval + simpa [JetGaugeGroupI.eval, JetGaugeGroupI.evalU1, + coeff_zero_eq_constantCoeff] using h3 + · rw [hU1 m hm0 hm, coeff_one, if_neg hm0] + · rw [JetRing.coeff_truncation_of_gt (not_le.mp hm), + JetRing.coeff_truncation_of_gt (not_le.mp hm)] + +end StandardModel diff --git a/Physlib/Particles/StandardModel/GaugeGroup/SU2PermDecomposition.lean b/Physlib/Particles/StandardModel/GaugeGroup/SU2PermDecomposition.lean new file mode 100644 index 000000000..a665b0691 --- /dev/null +++ b/Physlib/Particles/StandardModel/GaugeGroup/SU2PermDecomposition.lean @@ -0,0 +1,373 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Basic +public import Mathlib.LinearAlgebra.Eigenspace.Basic +/-! +# `SU(2)` permutation decompositions + +## i. Overview + +An **`SU(2)` permutation decomposition** of a submodule `V` is a `ZMod 4`-indexed family of +subspaces whose supremum is `V`, the grade-`k` piece scaled by `i ^ k` under the `SU(2)` +element + + `su2Perm = !![0, -1; 1, 0]`, + +the Weyl reflection of `SU(2)`. On a doublet it sends `(a, b)` to `(-b, a)`, exchanging the +two isospin components and so exchanging the isospin weights `+1` and `-1` that the third +coordinate of a `GaugeWeight` records. + +`su2Perm` squares to `-1`, so it has order four in `SU(2)` and `rep gaugeSU2Perm` satisfies +`T ^ 4 = 1`. Its spectrum is therefore contained in the fourth roots of unity, and the index +group is `ZMod 4` with eigenvalue `i ^ k` — multiplicative in `k`, which is what makes the +grading add under multiplication, exactly as gauge weights do in `GaugeWeightDecomposition`. +Because `ZMod 4` is finite there is no support field: the finiteness that +`GaugeWeightDecomposition.supp` has to record is automatic here. + +The four grades split by Higgs degree. On a product of an even number of Higgs symbols +`su2Perm` acts as an involution, so only the grades `0` and `2` occur — the eigenvalues `±1` +— and the `SU(2)` invariants sit in grade `0`. The grades `1` and `3`, at `±i`, are where the +odd-degree terms live: the Higgs doublet itself is spanned by `H⁰ - i H¹` in grade `1` and +`H⁰ + i H¹` in grade `3`. A `ZMod 2` version of this file would have nothing to say about +those sectors, and so nothing to say about the Yukawa terms. + +## ii. A warning: grade zero is weaker than invariance + +Like the isospin weight, this is a *sieve* rather than a characterization. +`mem_zero_of_invariant` says an invariant element has grade zero, and there is no converse. +What it buys is a genuine sharpening of the isospin weight in `GaugeWeightDecomposition`, +whose weight-zero piece cannot separate the isospin singlet from the neutral component of a +higher multiplet. Because `su2Perm` exchanges the two isospin components it acts on the +isospin-zero subspace, and its grade-`2` part is thrown away by this sieve. + +The sieve cannot be pushed further by grading alone. A grading sees only the abelian +subgroup generated by the elements it uses, and for any abelian subgroup of `SU(2)` the +invariants of that subgroup are strictly larger than the `SU(2)` invariants in high isospin — +the square of the neutral triplet component survives every such sieve. Cutting that down +needs the continuous symmetry, not another grading. + +## iii. Key results + +- `su2Perm` : the `SU(2)` Weyl element `!![0, -1; 1, 0]`, and `gaugeSU2Perm` its image in + the gauge group. +- `su2PermSign` : the character `k ↦ i ^ k` on `ZMod 4`, injective and multiplicative. +- `SU2PermDecomposition` : a `ZMod 4`-graded family of pure-sign subspaces with supremum `V`. +- `SU2PermDecomposition.sup` : two decompositions combine gradewise into one of `V ⊔ V'`. +- `SU2PermDecomposition.mul` : grades add under multiplication, decomposing `V * V'`. +- `SU2PermDecomposition.mem_zero_of_invariant` : a gauge-invariant element has grade zero. + +## iv. Table of contents + +- A. The `SU(2)` Weyl element +- B. The sign character of `ZMod 4` +- C. `SU(2)` permutation decompositions +- D. Joins +- E. Products +- F. Invariants + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix + +/-! + +## A. The `SU(2)` Weyl element + +-/ + +/-- The `SU(2)` Weyl element `!![0, -1; 1, 0]`. On a doublet it sends `(a, b)` to `(-b, a)`, + exchanging the two isospin components; it squares to `-1`, so it has order four in + `SU(2)`. -/ +noncomputable def su2Perm : specialUnitaryGroup (Fin 2) ℂ := + ⟨!![0, -1; 1, 0], by + rw [Matrix.mem_specialUnitaryGroup_iff] + refine ⟨?_, ?_⟩ + · rw [Matrix.mem_unitaryGroup_iff] + ext a b + fin_cases a <;> fin_cases b <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, star_eq_conjTranspose, + Matrix.conjTranspose_apply] + · simp [Matrix.det_fin_two_of]⟩ + +lemma su2Perm_coe : (su2Perm : specialUnitaryGroup (Fin 2) ℂ).1 = !![0, -1; 1, 0] := rfl + +/-- The inverse Weyl element is `!![0, 1; -1, 0]`. -/ +lemma su2Perm_inv_coe : + (su2Perm⁻¹ : specialUnitaryGroup (Fin 2) ℂ).1 = !![0, 1; -1, 0] := by + rw [← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star, su2Perm_coe] + ext a b + fin_cases a <;> fin_cases b <;> simp + +/-- The Weyl element as a gauge transformation: trivial on colour and hypercharge. -/ +noncomputable def gaugeSU2Perm : GaugeGroupI := ⟨1, su2Perm, 1⟩ + +/-! + +## B. The sign character of `ZMod 4` + +-/ + +/-- The fourth root of unity `i ^ k` attached to a grade `k : ZMod 4`: the eigenvalue of the + Weyl element on the `k` piece of a decomposition. -/ +noncomputable def su2PermSign (k : ZMod 4) : ℂ := + if k = 0 then 1 else if k = 1 then Complex.I else if k = 2 then -1 else -Complex.I + +@[simp] lemma su2PermSign_zero : su2PermSign 0 = 1 := rfl + +@[simp] lemma su2PermSign_one : su2PermSign 1 = Complex.I := rfl + +@[simp] lemma su2PermSign_two : su2PermSign 2 = -1 := rfl + +@[simp] lemma su2PermSign_three : su2PermSign 3 = -Complex.I := rfl + +/-- The sign is a character: grades **add** under multiplication because the fourth roots of + unity multiply. -/ +lemma su2PermSign_add (k l : ZMod 4) : + su2PermSign (k + l) = su2PermSign k * su2PermSign l := by + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + rcases hcases k with rfl | rfl | rfl | rfl <;> rcases hcases l with rfl | rfl | rfl | rfl <;> + simp [show (1 + 1 : ZMod 4) = 2 from by decide, + show (1 + 2 : ZMod 4) = 3 from by decide, show (1 + 3 : ZMod 4) = 0 from by decide, + show (2 + 1 : ZMod 4) = 3 from by decide, show (2 + 2 : ZMod 4) = 0 from by decide, + show (2 + 3 : ZMod 4) = 1 from by decide, show (3 + 1 : ZMod 4) = 0 from by decide, + show (3 + 2 : ZMod 4) = 1 from by decide, show (3 + 3 : ZMod 4) = 2 from by decide, + Complex.I_mul_I] + +lemma su2PermSign_ne_zero (k : ZMod 4) : su2PermSign k ≠ 0 := by + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + rcases hcases k with rfl | rfl | rfl | rfl <;> simp + +/-- The four fourth roots of unity are distinct, so the pieces of a decomposition sit in + eigenspaces at distinct eigenvalues and are automatically independent. -/ +lemma su2PermSign_injective : Function.Injective su2PermSign := by + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + intro k l hkl + rcases hcases k with rfl | rfl | rfl | rfl <;> rcases hcases l with rfl | rfl | rfl | rfl <;> + simp_all [Complex.ext_iff] <;> norm_num at hkl + +/-! + +## C. `SU(2)` permutation decompositions + +-/ + +variable {B : Type*} [Ring B] [Algebra ℂ B] + +/-- An **`SU(2)` permutation decomposition** of a submodule `V`: a `ZMod 4`-graded family of + subspaces of pure sign under the Weyl element `gaugeSU2Perm`, whose supremum is `V`. + + Unlike `GaugeWeightDecomposition` there is no support field — `ZMod 4` is finite, so the + finiteness condition is automatic. The four grades carry the four fourth roots of unity; + even-degree terms occupy grades `0` and `2`, odd-degree terms grades `1` and `3`. -/ +structure SU2PermDecomposition (rep : Representation ℂ GaugeGroupI B) + (V : Submodule ℂ B) where + /-- The grade `k` piece of the decomposition. -/ + piece : ZMod 4 → Submodule ℂ B + /-- Each piece is of pure sign under the Weyl element. -/ + piece_le : ∀ k, ∀ x, x ∈ piece k → rep gaugeSU2Perm x = su2PermSign k • x + /-- The pieces exhaust `V`. -/ + iSup_piece : (⨆ k, piece k) = V + +namespace SU2PermDecomposition + +variable {rep : Representation ℂ GaugeGroupI B} {V V' : Submodule ℂ B} + +/-- The grade-`k` piece lies in the `su2PermSign k` eigenspace of the Weyl element. This is + `piece_le` phrased as an inequality of submodules. -/ +lemma piece_le_eigenspace (d : SU2PermDecomposition rep V) (k : ZMod 4) : + d.piece k ≤ Module.End.eigenspace (rep gaugeSU2Perm) (su2PermSign k) := + fun _ hy => Module.End.mem_eigenspace_iff.mpr (d.piece_le k _ hy) + +/-- Transport a decomposition along an equality of submodules. -/ +def copy (d : SU2PermDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) : + SU2PermDecomposition rep W where + piece := d.piece + piece_le := d.piece_le + iSup_piece := by rw [d.iSup_piece, hW] + +@[simp] +lemma copy_piece (d : SU2PermDecomposition rep V) (W : Submodule ℂ B) (hW : W = V) : + (d.copy W hW).piece = d.piece := rfl + +/-! + +## D. Joins + +-/ + +/-- The join of two decompositions: the pieces and suprema combine gradewise, decomposing + `V ⊔ V'`. -/ +noncomputable def sup (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') : + SU2PermDecomposition rep (V ⊔ V') where + piece k := d.piece k ⊔ d'.piece k + piece_le k x hx := + Module.End.mem_eigenspace_iff.mp + (sup_le (d.piece_le_eigenspace k) (d'.piece_le_eigenspace k) hx) + iSup_piece := by + rw [iSup_sup_eq, d.iSup_piece, d'.iSup_piece] + +@[simp] +lemma sup_piece (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') + (k : ZMod 4) : (d.sup d').piece k = d.piece k ⊔ d'.piece k := rfl + +/-! + +## E. Products + +-/ + +/-- The product of two decompositions: grades **add** under multiplication, so the grade-`k` + piece of `V * V'` is spanned by the products of pieces whose grades sum to `k`. + + Multiplicativity of the representation is a hypothesis rather than a field: a + `Representation` records only a linear action. -/ +noncomputable def mul (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') : + SU2PermDecomposition rep (V * V') where + piece k := ⨆ k₁, ⨆ k₂, ⨆ _ : k₁ + k₂ = k, d.piece k₁ * d'.piece k₂ + piece_le k x hx := by + have key : (⨆ k₁, ⨆ k₂, ⨆ _ : k₁ + k₂ = k, d.piece k₁ * d'.piece k₂) + ≤ Module.End.eigenspace (rep gaugeSU2Perm) (su2PermSign k) := by + refine iSup_le fun k₁ => iSup_le fun k₂ => iSup_le fun hk => ?_ + refine Submodule.mul_le.mpr fun m hm n hn => ?_ + refine Module.End.mem_eigenspace_iff.mpr ?_ + rw [hmul, d.piece_le k₁ m hm, d'.piece_le k₂ n hn, smul_mul_smul_comm, + ← su2PermSign_add, hk] + exact Module.End.mem_eigenspace_iff.mp (key hx) + iSup_piece := by + refine le_antisymm (iSup_le fun k => iSup_le fun k₁ => iSup_le fun k₂ => + iSup_le fun _ => ?_) ?_ + · exact mul_le_mul' ((le_iSup d.piece k₁).trans d.iSup_piece.le) + ((le_iSup d'.piece k₂).trans d'.iSup_piece.le) + · have hV : (⨆ k₁, d.piece k₁) * (⨆ k₂, d'.piece k₂) = V * V' := by + rw [d.iSup_piece, d'.iSup_piece] + rw [← hV, Submodule.iSup_mul] + refine iSup_le fun k₁ => ?_ + rw [Submodule.mul_iSup] + refine iSup_le fun k₂ => ?_ + exact le_iSup_of_le (k₁ + k₂) + (le_iSup_of_le k₁ (le_iSup_of_le k₂ (le_iSup_of_le rfl le_rfl))) + +lemma mul_piece (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') (k : ZMod 4) : + (d.mul hmul d').piece k = ⨆ k₁, ⨆ k₂, ⨆ _ : k₁ + k₂ = k, d.piece k₁ * d'.piece k₂ := rfl + +/-- The grade-`k` piece of a product, with the second grade solved for: the double join + collapses to a single one. -/ +lemma mul_piece_eq_sub + (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') (k : ZMod 4) : + (d.mul hmul d').piece k = ⨆ k₁, d.piece k₁ * d'.piece (k - k₁) := by + rw [mul_piece] + refine le_antisymm (iSup_le fun k₁ => iSup_le fun k₂ => iSup_le fun hk => ?_) ?_ + · exact le_iSup_of_le k₁ (by rw [eq_sub_of_add_eq' hk]) + · exact iSup_le fun k₁ => + le_iSup_of_le k₁ (le_iSup_of_le (k - k₁) (le_iSup_of_le (add_sub_cancel k₁ k) le_rfl)) + +/-- **The grade-`k` piece of a product, written out.** `ZMod 4` has four elements, so the + join is a four-term one. -/ +lemma mul_piece_eq (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (d' : SU2PermDecomposition rep V') (k : ZMod 4) : + (d.mul hmul d').piece k + = d.piece 0 * d'.piece k ⊔ d.piece 1 * d'.piece (k - 1) + ⊔ d.piece 2 * d'.piece (k - 2) ⊔ d.piece 3 * d'.piece (k - 3) := by + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + rw [mul_piece_eq_sub] + refine le_antisymm (iSup_le fun k₁ => ?_) (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) + · rcases hcases k₁ with rfl | rfl | rfl | rfl + · rw [sub_zero] + exact le_sup_of_le_left (le_sup_of_le_left le_sup_left) + · exact le_sup_of_le_left (le_sup_of_le_left le_sup_right) + · exact le_sup_of_le_left le_sup_right + · exact le_sup_right + · exact le_iSup_of_le 0 (by rw [sub_zero]) + · exact le_iSup_of_le 1 le_rfl + · exact le_iSup_of_le 2 le_rfl + · exact le_iSup_of_le 3 le_rfl + +/-- The unit submodule has grade zero: the identity of `B` is fixed by every gauge + transformation, provided the representation preserves the unit. -/ +noncomputable def one (hone : ∀ g : GaugeGroupI, rep g 1 = 1) : + SU2PermDecomposition rep (1 : Submodule ℂ B) where + piece k := if k = 0 then 1 else ⊥ + piece_le := by + intro k x hx + rcases eq_or_ne k 0 with rfl | hk + · rw [if_pos rfl, Submodule.one_eq_span, Submodule.mem_span_singleton] at hx + obtain ⟨c, rfl⟩ := hx + rw [map_smul, hone, su2PermSign_zero, one_smul] + · rw [if_neg hk, Submodule.mem_bot] at hx + subst hx + simp + iSup_piece := by + refine le_antisymm (iSup_le fun k => ?_) (le_iSup_of_le 0 (le_of_eq (if_pos rfl).symm)) + by_cases hk : k = 0 + · rw [if_pos hk] + · rw [if_neg hk] + exact bot_le + +@[simp] +lemma one_piece (hone : ∀ g : GaugeGroupI, rep g 1 = 1) (k : ZMod 4) : + (one (B := B) (rep := rep) hone).piece k = if k = 0 then 1 else ⊥ := rfl + +/-- Powers of a decomposed submodule: grades add, so `V ^ n` inherits a decomposition, built + by iterating `mul` from `one`. -/ +noncomputable def pow (hone : ∀ g : GaugeGroupI, rep g 1 = 1) + (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) : + (n : ℕ) → SU2PermDecomposition rep (V ^ n) + | 0 => (one hone).copy _ (pow_zero V) + | (n + 1) => ((pow hone hmul d n).mul hmul d).copy _ (pow_succ V n) + +@[simp] +lemma pow_zero_piece (hone : ∀ g : GaugeGroupI, rep g 1 = 1) + (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (k : ZMod 4) : + (d.pow hone hmul 0).piece k = if k = 0 then 1 else ⊥ := rfl + +@[simp] +lemma pow_succ_piece (hone : ∀ g : GaugeGroupI, rep g 1 = 1) + (hmul : ∀ (g : GaugeGroupI) (x y : B), rep g (x * y) = rep g x * rep g y) + (d : SU2PermDecomposition rep V) (n : ℕ) (k : ZMod 4) : + (d.pow hone hmul (n + 1)).piece k + = ⨆ k₁, ⨆ k₂, ⨆ _ : k₁ + k₂ = k, (d.pow hone hmul n).piece k₁ * d.piece k₂ := rfl + +/-! + +## F. Invariants + +-/ + +/-- **A gauge-invariant element has grade zero.** Only invariance under the single Weyl + element `gaugeSU2Perm` is used: the other pieces lie in eigenspaces at `i`, `-1` and `-i`, + all distinct from `1`. + + There is no converse; see the warning in the module docstring. -/ +lemma mem_zero_of_invariant (d : SU2PermDecomposition rep V) {x : B} (hx : x ∈ V) + (hV : ∀ g : GaugeGroupI, rep g x = x) : x ∈ d.piece 0 := by + have hdisj : Disjoint + (Module.End.eigenspace (rep gaugeSU2Perm) (su2PermSign 0)) + (⨆ k, ⨆ _ : k ≠ (0 : ZMod 4), d.piece k) := + (((Module.End.eigenspaces_iSupIndep (rep gaugeSU2Perm : Module.End ℂ B)).comp + su2PermSign_injective) 0).mono_right (iSup₂_mono fun k _ => d.piece_le_eigenspace k) + have key : (⨆ k, d.piece k) + ⊓ Module.End.eigenspace (rep gaugeSU2Perm) (su2PermSign 0) ≤ d.piece 0 := by + rw [iSup_split_single d.piece 0, sup_inf_assoc_of_le _ (d.piece_le_eigenspace 0)] + exact sup_le le_rfl (hdisj.symm.le_bot.trans bot_le) + refine key ⟨?_, Module.End.mem_eigenspace_iff.mpr ?_⟩ + · rw [d.iSup_piece] + exact hx + · rw [su2PermSign_zero, one_smul] + exact hV _ + +end SU2PermDecomposition +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/AlgebraValued/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/AlgebraValued/Basic.lean new file mode 100644 index 000000000..aca6d8933 --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/AlgebraValued/Basic.lean @@ -0,0 +1,5155 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.HiggsBoson.Basic +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading +public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +public import Mathlib.RepresentationTheory.Invariants +/-! +# The algebra valued Higgs boson + +We suppose that we have an equivariant map +under the global gauge group, and the Lorentz group +`H : Module.Dual ℂ HiggsVec →ₗ[ℂ] B` +and +`barH : Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B` +from the dual of the Higgs space to some algebra `B`. The Higgs is a Lorentz scalar, so +Lorentz equivariance carries no content for `H` itself and is not recorded as a field. + +We define `IsHiggsAlgebraValued` to be the property that these maps are equivariant under +the gauge group and the Lorentz group, and there images commute with one another. + +We let `higgsSubModule` be the submodule of `B` generated by the images of `H`, +and `barHiggsSubModule` be the submodule of `B` generated by the images of `barH`. + +The algebra `B` carries a grading due to hypercharge, through its representation +of the global gauge group. This grading can be used to eliminate +a large collection of the possible terms in the lagrangian. + +We want to consider invariants within +- `higgsSubModule * barHiggsSubModule` + +We also want to consider derivatives. + +The invariance involving the Higgs fields, up to +mass-dimension 4 are given by: +`H^† D_μ D_μ H`,`H D_μ D_μ H^†`, `D_μ H D_μ H^†`, `H H^†` and `(H^† H)^2`. + + + +So let +`x := a0 TT + a1 XX + a2 YY + a3 ZZ`. + +Write `M := TT - XX - YY - ZZ` for the target, and abbreviate the three coefficients +appearing in the conditions by +`u := a0 + a1`, `v := a0 + a2`, `w := a0 + a3`. +Expanding `M` gives the identity +`x = a0 M + u XX + v YY + w ZZ`. + +Rotational average gives +`x = a0 M + (u + v + w)/3 (XX + YY + ZZ)`. + +while the three boost conditions read `u (TT + XX) = 0`, `v (TT + YY) = 0` and +`w (TT + ZZ) = 0`, that is `u XX = - u TT`, `v YY = - v TT` and `w ZZ = - w TT`. +Substituting these in, +`x = a0 M - (u + v + w) TT`. + +So we must have that `(u+v+w) TT = (u+v+w) M / 4`, and hence +`x = ( a0 - (u + v + w) / 4 ) M`. +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + + +/-- The pair of symbol maps `H`, `barH` in the algebra `B` is an *algebra-valued Higgs* for + the gauge representation `rep` when it satisfies the defining properties of the physicists' + Higgs doublet: + + * the symbol `H_φ` transforms contragrediently to `HiggsVec` — under a gauge transformation + `g` it is acted on by the dual representation `HiggsVec.repGaugeGroupI.dual` + (`H_equivariant`), and `barH_φ` by the conjugate-dual (`barH_equivariant`). These are the + physicists' `H ↦ g H` and `H^† ↦ H^† g^†`, read on the component functions; + * the Higgs is a *boson*, so all of its component symbols commute with one another + (`H_comm_H`, `H_comm_barH`, `barH_comm_barH`). This is what distinguishes an + algebra-valued Higgs from an algebra-valued fermion, whose symbols anticommute; + * a gauge transformation acts on `B` by an *algebra* map (`rep_mul`). A `Representation` + records only a linear action, so multiplicativity has to be demanded separately; it is + what lets the gauge action be transported through products of symbols. -/ +structure IsHiggsAlgebraValued (B : Type*) [Semiring B] [Algebra ℂ B] + (rep : Representation ℂ GaugeGroupI B) + (repLorentz : Representation ℂ SL(2,ℂ) B) + (H : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B) + (barH : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B) + (massWeightPoly : B →ₐ[ℂ] Polynomial B) : Prop where + /-- The Higgs symbol carries the dual of the gauge representation on `HiggsVec`: the + `SU(2)` index transforms contragrediently, and the hypercharge character by `u⁻³`. -/ + H_equivariant : ∀ (g : GaugeGroupI) (φ : Module.Dual ℂ HiggsVec) n l, + rep g (H n l φ) = H n l (HiggsVec.repGaugeGroupI.dual g φ) + /-- The conjugate Higgs symbol carries the conjugate-dual of the gauge representation: + the physicists' `H^† ↦ H^† g^†`. -/ + barH_equivariant : ∀ (g : GaugeGroupI) (φ : Module.Dual ℂ (ConjModule HiggsVec)) n l, + rep g (barH n l φ) = barH n l (HiggsVec.repGaugeGroupI.conj.dual g φ) + /-- Gauge transformations act on `B` by algebra maps: the representation is + multiplicative. -/ + rep_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), rep g (b₁ * b₂) = rep g b₁ * rep g b₂ + /-- Lorentz transformations act on `B` by algebra maps: the representation is + multiplicative. -/ + repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ + /-- The Higgs is bosonic: two Higgs symbols commute. -/ + H_comm_H : ∀ φ ψ n1 n2 l1 l2, Commute (H n1 l1 φ) (H n2 l2 ψ) + /-- A Higgs symbol commutes with a conjugate Higgs symbol. -/ + H_comm_barH : ∀ φ ψ n1 n2 l1 l2, Commute (H n1 l1 φ) (barH n2 l2 ψ) + /-- Two conjugate Higgs symbols commute. -/ + barH_comm_barH : ∀ φ ψ n1 n2 l1 l2, Commute (barH n1 l1 φ) (barH n2 l2 ψ) + H_massWeight : ∀ φ n l, massWeightPoly (H n l φ) = Polynomial.monomial (2 * (1 + n)) (H n l φ) + barH_massWeight : ∀ φ n l, massWeightPoly (barH n l φ) = Polynomial.monomial (2 * (1 + n)) (barH n l φ) + /-- The action of the Lorentz group on H. -/ + repLorentz_H : ∀ (g : SL(2,ℂ)) (φ : Module.Dual ℂ HiggsVec) n l, + repLorentz g (H n l φ) = ∑ (a : Fin n → Fin 1 ⊕ Fin 3), + (∏ (i : Fin n), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • H n a φ + /-- The action of the Lorentz group on barH. -/ + repLorentz_barH : ∀ (g : SL(2,ℂ)) (φ : Module.Dual ℂ (ConjModule HiggsVec)) n l, + repLorentz g (barH n l φ) = ∑ (a : Fin n → Fin 1 ⊕ Fin 3), + (∏ (i : Fin n), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • barH n a φ + +set_option linter.unusedVariables false +namespace IsHiggsAlgebraValued + +variable {B : Type*} [Ring B] [Algebra ℂ B] + {rep : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {H : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B} + {barH : (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) + + +/-! + +## A. The basic generators and the submodules generated by them. + +-/ + +/-- The component `∇_d H^i` in the algebra. -/ +noncomputable def higgs (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) + {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) :B := + H n d (HiggsVec.orthonormBasis.toBasis.dualBasis i) + +/-- The component `∇_d barH^i` in the algebra. -/ +noncomputable def barHiggs (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) + {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) : B := + barH n d (HiggsVec.orthonormBasis.toBasis.conj.dualBasis i) + +/-! + +### A.1. The representation of the gauge group on the components + +-/ + + +lemma rep_higgsComponent (g : GaugeGroupI) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) : + rep g (h.higgs d i) = + ∑ j, (((g⁻¹).toU1 : ℂ) ^ 3 * (g⁻¹).toSU2.1 i j) • h.higgs d j := by + have key : HiggsVec.repGaugeGroupI.dual g (HiggsVec.orthonormBasis.toBasis.dualBasis i) + = ∑ j, (((g⁻¹).toU1 : ℂ) ^ 3 * (g⁻¹).toSU2.1 i j) • + HiggsVec.orthonormBasis.toBasis.dualBasis j := by + refine HiggsVec.orthonormBasis.toBasis.ext fun k => ?_ + rw [LinearMap.sum_apply] + simp only [LinearMap.smul_apply, smul_eq_mul, Module.Basis.dualBasis_apply_self, + mul_ite, mul_one, mul_zero, Finset.sum_ite_eq] + simp [Representation.dual, HiggsVec.repGaugeGroupI_apply, HiggsVec.orthonormBasis, + Submonoid.smul_def, -inv_pow] + rw [higgs, h.H_equivariant, key, map_sum] + exact Finset.sum_congr rfl fun j _ => by rw [map_smul]; rfl + + +lemma rep_barHiggsComponent (g : GaugeGroupI) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2) : + rep g (h.barHiggs d i) = + ∑ j, (starRingEnd ℂ (((g⁻¹).toU1 : ℂ) ^ 3 * (g⁻¹).toSU2.1 i j)) • h.barHiggs d j := by + have key : HiggsVec.repGaugeGroupI.conj.dual g + (HiggsVec.orthonormBasis.toBasis.conj.dualBasis i) + = ∑ j, (starRingEnd ℂ (((g⁻¹).toU1 : ℂ) ^ 3 * (g⁻¹).toSU2.1 i j)) • + HiggsVec.orthonormBasis.toBasis.conj.dualBasis j := by + refine HiggsVec.orthonormBasis.toBasis.conj.ext fun k => ?_ + rw [LinearMap.sum_apply] + simp only [LinearMap.smul_apply, smul_eq_mul, Module.Basis.dualBasis_apply_self, + mul_ite, mul_one, mul_zero, Finset.sum_ite_eq] + simp [Representation.dual, Representation.conj_apply, HiggsVec.repGaugeGroupI_apply, + HiggsVec.orthonormBasis, Submonoid.smul_def, -inv_pow] + rw [barHiggs, h.barH_equivariant, key, map_sum] + exact Finset.sum_congr rfl fun j _ => by rw [map_smul]; rfl + +/-! + +### A.2. The submodules generated by the Higges and conjugate Higgs components + +-/ + +/-- The submodule of `B` generated by the Higgs symbols carrying `n` derivatives: the join, + over the Lorentz indices `d`, of the ranges of the symbol maps `H n d`. Its elements are + the terms linear in `∇_d H` — of mass dimension `1 + n`. -/ +def higgsSubmodule (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) (n : ℕ) : + Submodule ℂ B := ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (H n d) + +/-- The submodule of `B` generated by the conjugate Higgs symbols carrying `n` derivatives: + the join, over the Lorentz indices `d`, of the ranges of the symbol maps `barH n d`. -/ +def barHiggsSubmodule (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) + (n : ℕ) : Submodule ℂ B := ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), LinearMap.range (barH n d) + +/-! + +### A.n. Commutativity of higgs and barHiggsSubmodules + +-/ + +@[simp] +lemma barHiggsSubmodule_comm_higgsSubmodule (n1 n2 : ℕ) : + (h.barHiggsSubmodule n1) * (h.higgsSubmodule n2) + = (h.higgsSubmodule n2) * (h.barHiggsSubmodule n1) := by + have gen : ∀ (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + h.higgsSubmodule n2 ≤ LinearMap.ker (LinearMap.mulLeft ℂ (barH n1 d1 φ) + - LinearMap.mulRight ℂ (barH n1 d1 φ)) := by + intro d1 φ + rw [higgsSubmodule] + refine iSup_le fun d2 => ?_ + rintro _ ⟨ψ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] + exact (h.H_comm_barH ψ φ n2 n1 d2 d1).symm.eq + have key : ∀ x ∈ h.barHiggsSubmodule n1, ∀ y ∈ h.higgsSubmodule n2, x * y = y * x := by + intro x hx y hy + have step : h.barHiggsSubmodule n1 + ≤ LinearMap.ker (LinearMap.mulRight ℂ y - LinearMap.mulLeft ℂ y) := by + rw [barHiggsSubmodule] + refine iSup_le fun d1 => ?_ + rintro _ ⟨φ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] + have := gen d1 φ hy + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] using this + have := step hx + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] using this + refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_) + (Submodule.mul_le.mpr fun y hy x hx => ?_) + · rw [key x hx y hy] + exact Submodule.mul_mem_mul hy hx + · rw [← key x hx y hy] + exact Submodule.mul_mem_mul hx hy + +lemma higgsSubmodule_comm_higgsSubmodule (n1 n2 : ℕ) (h1 : n1 < n2) : + (h.higgsSubmodule n1) * (h.higgsSubmodule n2) + = (h.higgsSubmodule n2) * (h.higgsSubmodule n1) := by + have gen : ∀ (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + h.higgsSubmodule n2 ≤ LinearMap.ker (LinearMap.mulLeft ℂ (H n1 d1 φ) + - LinearMap.mulRight ℂ (H n1 d1 φ)) := by + intro d1 φ + rw [higgsSubmodule] + refine iSup_le fun d2 => ?_ + rintro _ ⟨ψ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] + exact (h.H_comm_H φ ψ n1 n2 d1 d2).eq + have key : ∀ x ∈ h.higgsSubmodule n1, ∀ y ∈ h.higgsSubmodule n2, x * y = y * x := by + intro x hx y hy + have step : h.higgsSubmodule n1 + ≤ LinearMap.ker (LinearMap.mulRight ℂ y - LinearMap.mulLeft ℂ y) := by + rw [higgsSubmodule] + refine iSup_le fun d1 => ?_ + rintro _ ⟨φ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] + have := gen d1 φ hy + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] using this + have := step hx + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] using this + refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_) + (Submodule.mul_le.mpr fun y hy x hx => ?_) + · rw [key x hx y hy] + exact Submodule.mul_mem_mul hy hx + · rw [← key x hx y hy] + exact Submodule.mul_mem_mul hx hy + +lemma barHiggsSubmodule_comm_barHiggsSubmodule (n1 n2 : ℕ) (h1 : n1 < n2) : + (h.barHiggsSubmodule n1) * (h.barHiggsSubmodule n2) + = (h.barHiggsSubmodule n2) * (h.barHiggsSubmodule n1) := by + have gen : ∀ (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + h.barHiggsSubmodule n2 ≤ LinearMap.ker (LinearMap.mulLeft ℂ (barH n1 d1 φ) + - LinearMap.mulRight ℂ (barH n1 d1 φ)) := by + intro d1 φ + rw [barHiggsSubmodule] + refine iSup_le fun d2 => ?_ + rintro _ ⟨ψ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] + exact (h.barH_comm_barH φ ψ n1 n2 d1 d2).eq + have key : ∀ x ∈ h.barHiggsSubmodule n1, ∀ y ∈ h.barHiggsSubmodule n2, x * y = y * x := by + intro x hx y hy + have step : h.barHiggsSubmodule n1 + ≤ LinearMap.ker (LinearMap.mulRight ℂ y - LinearMap.mulLeft ℂ y) := by + rw [barHiggsSubmodule] + refine iSup_le fun d1 => ?_ + rintro _ ⟨φ, rfl⟩ + simp only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] + have := gen d1 φ hy + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulLeft_apply, + LinearMap.mulRight_apply, sub_eq_zero] using this + have := step hx + simpa only [LinearMap.mem_ker, LinearMap.sub_apply, LinearMap.mulRight_apply, + LinearMap.mulLeft_apply, sub_eq_zero] using this + refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_) + (Submodule.mul_le.mpr fun y hy x hx => ?_) + · rw [key x hx y hy] + exact Submodule.mul_mem_mul hy hx + · rw [← key x hx y hy] + exact Submodule.mul_mem_mul hx hy + +/-! + +### A.3. The closure of the Higgs and conjugate Higgs submodules under the gauge group + +-/ + +lemma higgsSubmodule_map_rep_le (n : ℕ) (g : GaugeGroupI) : + (h.higgsSubmodule n).map (rep g) ≤ h.higgsSubmodule n := by + rw [higgsSubmodule, Submodule.map_iSup] + refine iSup_le fun d => ?_ + rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩ + exact Submodule.mem_iSup_of_mem d + ⟨HiggsVec.repGaugeGroupI.dual g φ, (h.H_equivariant g φ n d).symm⟩ + +/-- The Higgs symbols are closed under the gauge action.-/ +lemma higgsSubmodule_closure (n : ℕ) (g : GaugeGroupI) : + (h.higgsSubmodule n).map (rep g) = h.higgsSubmodule n := + le_antisymm (h.higgsSubmodule_map_rep_le n g) fun b hb => + ⟨rep g⁻¹ b, h.higgsSubmodule_map_rep_le n g⁻¹ ⟨b, hb, rfl⟩, rep.self_inv_apply g b⟩ + +lemma barHiggsSubmodule_map_rep_le (n : ℕ) (g : GaugeGroupI) : + (h.barHiggsSubmodule n).map (rep g) ≤ h.barHiggsSubmodule n := by + rw [barHiggsSubmodule, Submodule.map_iSup] + refine iSup_le fun d => ?_ + rintro _ ⟨_, ⟨φ, rfl⟩, rfl⟩ + exact Submodule.mem_iSup_of_mem d + ⟨HiggsVec.repGaugeGroupI.conj.dual g φ, (h.barH_equivariant g φ n d).symm⟩ + +/-- The conjugate Higgs symbols are closed under the gauge action. -/ +lemma barHiggsSubmodule_closure (n : ℕ) (g : GaugeGroupI) : + (h.barHiggsSubmodule n).map (rep g) = h.barHiggsSubmodule n := + le_antisymm (h.barHiggsSubmodule_map_rep_le n g) fun b hb => + ⟨rep g⁻¹ b, h.barHiggsSubmodule_map_rep_le n g⁻¹ ⟨b, hb, rfl⟩, rep.self_inv_apply g b⟩ + +/-! + +### A.4. The gauge decomposition + +-/ + + +/-! + +#### A.4.1. The action of the gauge torus on the Higgs components + +-/ + +lemma rep_gaugeTorusGen_higgs_zero (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep (gaugeTorusGen i) (h.higgs d 0) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, -1, -3) i) • h.higgs d 0 := by + have hstar : ((starRingEnd ℂ) (expI : ℂ)) ^ 3 = (((expI : ℂ)) ^ 3)⁻¹ := by + rw [← inv_pow] + congr 1 + exact expI_inv_eq_star.symm + rw [h.rep_higgsComponent] + fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, + Fin.sum_univ_two, expI_inv_eq_star, Matrix.one_apply, Unitary.coe_inv, hstar] + rfl + +lemma rep_gaugeTorusGen_higg_one (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep (gaugeTorusGen i) (h.higgs d 1) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, 1, -3) i) • h.higgs d 1 := by + have hstar : ((starRingEnd ℂ) (expI : ℂ)) ^ 3 = (((expI : ℂ)) ^ 3)⁻¹ := by + rw [← inv_pow] + congr 1 + exact expI_inv_eq_star.symm + rw [h.rep_higgsComponent] + fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, + Fin.sum_univ_two, expI_inv_eq_star, Matrix.one_apply, Unitary.coe_inv, hstar] + rfl + +lemma rep_gaugeTorusGen_barHiggsComponent_zero (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep (gaugeTorusGen i) (h.barHiggs d 0) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, 1, 3) i) • h.barHiggs d 0 := by + have hc : (starRingEnd ℂ) (expI : ℂ) = ((expI : ℂ))⁻¹ := expI_inv_eq_star.symm + rw [h.rep_barHiggsComponent] + fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, + Fin.sum_univ_two, Matrix.one_apply, Unitary.coe_inv, hc] + rfl + +lemma rep_gaugeTorusGen_barHiggsComponent_one (i : Fin 4) {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep (gaugeTorusGen i) (h.barHiggs d 1) + = ((expI : ℂ) ^ GaugeWeight.coord (0, 0, -1, 3) i) • h.barHiggs d 1 := by + have hc : (starRingEnd ℂ) (expI : ℂ) = ((expI : ℂ))⁻¹ := expI_inv_eq_star.symm + rw [h.rep_barHiggsComponent] + fin_cases i <;> + simp [gaugeTorusGen, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2ExpI_inv_coe, + Fin.sum_univ_two, Matrix.one_apply, Unitary.coe_inv, hc] + rfl + +/-! + +#### A.4.1b. The action of the Weyl element on the Higgs components + +-/ + +lemma rep_gaugeSU2Perm_higgsComponent_zero {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.higgs d 0) = h.higgs d 1 := by + rw [h.rep_higgsComponent] + simp [gaugeSU2Perm, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2Perm_inv_coe, Fin.sum_univ_two] + +lemma rep_gaugeSU2Perm_higgsComponent_one {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.higgs d 1) = -h.higgs d 0 := by + rw [h.rep_higgsComponent] + simp [gaugeSU2Perm, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2Perm_inv_coe, Fin.sum_univ_two] + +lemma rep_gaugeSU2Perm_barHiggsComponent_zero {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.barHiggs d 0) = h.barHiggs d 1 := by + rw [h.rep_barHiggsComponent] + simp [gaugeSU2Perm, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2Perm_inv_coe, Fin.sum_univ_two] + +lemma rep_gaugeSU2Perm_barHiggsComponent_one {n : ℕ} (d : Fin n → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.barHiggs d 1) = -h.barHiggs d 0 := by + rw [h.rep_barHiggsComponent] + simp [gaugeSU2Perm, GaugeGroupI.toU1, GaugeGroupI.toSU2, su2Perm_inv_coe, Fin.sum_univ_two] + +/-- The mass-term pairing `∇H⁰ ∇H̄⁰ + ∇H¹ ∇H̄¹` is invariant under the Weyl element, + for any derivative indices on the two factors. -/ +lemma rep_gaugeSU2Perm_higgsBarHiggs_add {n1 n2 : ℕ} (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) + (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.higgs d1 0 * h.barHiggs d2 0 + h.higgs d1 1 * h.barHiggs d2 1) + = h.higgs d1 0 * h.barHiggs d2 0 + h.higgs d1 1 * h.barHiggs d2 1 := by + rw [map_add, h.rep_mul, h.rep_mul, h.rep_gaugeSU2Perm_higgsComponent_zero, + h.rep_gaugeSU2Perm_barHiggsComponent_zero, h.rep_gaugeSU2Perm_higgsComponent_one, + h.rep_gaugeSU2Perm_barHiggsComponent_one, neg_mul_neg, add_comm] + +/-- The triplet-term pairing `∇H⁰ ∇H̄⁰ - ∇H¹ ∇H̄¹` changes sign under the Weyl element, + for any derivative indices on the two factors. -/ +lemma rep_gaugeSU2Perm_higgsBarHiggs_sub {n1 n2 : ℕ} (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) + (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.higgs d1 0 * h.barHiggs d2 0 - h.higgs d1 1 * h.barHiggs d2 1) + = -(h.higgs d1 0 * h.barHiggs d2 0 - h.higgs d1 1 * h.barHiggs d2 1) := by + rw [map_sub, h.rep_mul, h.rep_mul, h.rep_gaugeSU2Perm_higgsComponent_zero, + h.rep_gaugeSU2Perm_barHiggsComponent_zero, h.rep_gaugeSU2Perm_higgsComponent_one, + h.rep_gaugeSU2Perm_barHiggsComponent_one, neg_mul_neg, neg_sub] + +/-- The diagonal quartic combination `(H⁰H̄⁰)² + (H¹H̄¹)²` is invariant under the Weyl + element. -/ +lemma rep_gaugeSU2Perm_quartic_add : + rep gaugeSU2Perm (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) + = h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 := by + simp only [map_add, h.rep_mul, h.rep_gaugeSU2Perm_higgsComponent_zero, + h.rep_gaugeSU2Perm_higgsComponent_one, h.rep_gaugeSU2Perm_barHiggsComponent_zero, + h.rep_gaugeSU2Perm_barHiggsComponent_one, mul_neg, neg_mul, neg_neg] + rw [add_comm] + +/-- The diagonal quartic combination `(H⁰H̄⁰)² - (H¹H̄¹)²` changes sign under the Weyl + element. -/ +lemma rep_gaugeSU2Perm_quartic_sub : + rep gaugeSU2Perm (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + - h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) + = -(h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + - h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) := by + simp only [map_sub, h.rep_mul, h.rep_gaugeSU2Perm_higgsComponent_zero, + h.rep_gaugeSU2Perm_higgsComponent_one, h.rep_gaugeSU2Perm_barHiggsComponent_zero, + h.rep_gaugeSU2Perm_barHiggsComponent_one, mul_neg, neg_mul, neg_neg] + rw [neg_sub] + +/-- The mixed quartic `H⁰H̄⁰H¹H̄¹` is invariant under the Weyl element. -/ +lemma rep_gaugeSU2Perm_quartic_mixed : + rep gaugeSU2Perm (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1) + = h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1 := by + have hbh2 : ∀ (a b : Fin 2), h.barHiggs ![] a * h.higgs ![] b + = h.higgs ![] b * h.barHiggs ![] a := + fun a b => ((h.H_comm_barH _ _ _ _ _ _).symm).eq + have hhh' : ∀ (c : B), h.higgs ![] 1 * (h.higgs ![] 0 * c) + = h.higgs ![] 0 * (h.higgs ![] 1 * c) := + fun c => (h.H_comm_H _ _ _ _ _ _).left_comm c + have hbb2 : h.barHiggs ![] 1 * h.barHiggs ![] 0 = h.barHiggs ![] 0 * h.barHiggs ![] 1 := + (h.barH_comm_barH _ _ _ _ _ _).eq + simp only [h.rep_mul, h.rep_gaugeSU2Perm_higgsComponent_zero, + h.rep_gaugeSU2Perm_higgsComponent_one, h.rep_gaugeSU2Perm_barHiggsComponent_zero, + h.rep_gaugeSU2Perm_barHiggsComponent_one, mul_neg, neg_mul, neg_neg, + mul_assoc, hbh2, hhh', hbb2] + +/-! + +#### A.4.2. The gauge decomposition on the Higgs submodule + +-/ + +@[simps!] +noncomputable instance higgsSubmoduleGaugeWeight (n : ℕ) : + GaugeWeightDecomposition rep (h.higgsSubmodule n) where + rep_mul := h.rep_mul + piece := fun w => + if w = (0, 0, -1, -3) then ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.higgs d 0} + else if w = (0, 0, 1, -3) then ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.higgs d 1} + else ⊥ + supp := {(0, 0, -1, -3), (0, 0, 1, -3)} + piece_le := by + have hz : ∀ i : Fin 4, (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.higgs d 0}) + ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) + ((expI : ℂ) ^ GaugeWeight.coord (0, 0, -1, -3) i) := fun i => + iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr + (Module.End.mem_eigenspace_iff.mpr (h.rep_gaugeTorusGen_higgs_zero i d)) + have ho : ∀ i : Fin 4, (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.higgs d 1}) + ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) + ((expI : ℂ) ^ GaugeWeight.coord (0, 0, 1, -3) i) := fun i => + iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr + (Module.End.mem_eigenspace_iff.mpr (h.rep_gaugeTorusGen_higg_one i d)) + intro w x hx i + rcases eq_or_ne w (0, 0, -1, -3) with rfl | hw0 + · rw [if_pos rfl] at hx + exact Module.End.mem_eigenspace_iff.mp (hz i hx) + · rcases eq_or_ne w (0, 0, 1, -3) with rfl | hw1 + · rw [if_neg hw0, if_pos rfl] at hx + exact Module.End.mem_eigenspace_iff.mp (ho i hx) + · rw [if_neg hw0, if_neg hw1, Submodule.mem_bot] at hx + subst hx + simp + piece_eq_bot := by + intro w hw + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hw + rw [if_neg hw.1, if_neg hw.2] + iSup_piece := by + have hrange : ∀ d : Fin n → (Fin 1 ⊕ Fin 3), + LinearMap.range (H n d) = Submodule.span ℂ (Set.range (h.higgs d)) := fun d => by + rw [LinearMap.range_eq_map, ← (HiggsVec.orthonormBasis.toBasis.dualBasis).span_eq, + Submodule.map_span, ← Set.range_comp] + rfl + have hmem : ∀ (d : Fin n → (Fin 1 ⊕ Fin 3)) (j : Fin 2), + h.higgs d j ∈ h.higgsSubmodule n := fun d j => + Submodule.mem_iSup_of_mem d ⟨HiggsVec.orthonormBasis.toBasis.dualBasis j, rfl⟩ + refine le_antisymm (iSup_le fun w => ?_) ?_ + · rcases eq_or_ne w (0, 0, -1, -3) with rfl | hw0 + · rw [if_pos rfl] + exact iSup_le fun d => + (Submodule.span_singleton_le_iff_mem _ _).mpr (hmem d 0) + · rcases eq_or_ne w (0, 0, 1, -3) with rfl | hw1 + · rw [if_neg hw0, if_pos rfl] + exact iSup_le fun d => + (Submodule.span_singleton_le_iff_mem _ _).mpr (hmem d 1) + · rw [if_neg hw0, if_neg hw1] + exact bot_le + · rw [higgsSubmodule] + refine iSup_le fun d => ?_ + rw [hrange d, Submodule.span_le] + rintro _ ⟨j, rfl⟩ + fin_cases j + · refine Submodule.mem_iSup_of_mem (0, 0, -1, -3) ?_ + rw [if_pos rfl] + exact Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _) + · refine Submodule.mem_iSup_of_mem (0, 0, 1, -3) ?_ + rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _) + +/-! + +#### A.4.2. The gauge decomposition on the conjugate Higgs submodule + +-/ + +@[simps!] +noncomputable instance barHiggsSubmoduleGaugeWeight (n : ℕ) : + GaugeWeightDecomposition rep (h.barHiggsSubmodule n) where + rep_mul := h.rep_mul + piece := fun w => + if w = (0, 0, 1, 3) then ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.barHiggs d 0} + else if w = (0, 0, -1, 3) then + ⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.barHiggs d 1} + else ⊥ + supp := {(0, 0, 1, 3), (0, 0, -1, 3)} + piece_le := by + have hz : ∀ i : Fin 4, (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.barHiggs d 0}) + ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) + ((expI : ℂ) ^ GaugeWeight.coord (0, 0, 1, 3) i) := fun i => + iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr + (Module.End.mem_eigenspace_iff.mpr (h.rep_gaugeTorusGen_barHiggsComponent_zero i d)) + have ho : ∀ i : Fin 4, (⨆ d : Fin n → (Fin 1 ⊕ Fin 3), Submodule.span ℂ {h.barHiggs d 1}) + ≤ Module.End.eigenspace (rep (gaugeTorusGen i)) + ((expI : ℂ) ^ GaugeWeight.coord (0, 0, -1, 3) i) := fun i => + iSup_le fun d => (Submodule.span_singleton_le_iff_mem _ _).mpr + (Module.End.mem_eigenspace_iff.mpr (h.rep_gaugeTorusGen_barHiggsComponent_one i d)) + intro w x hx i + rcases eq_or_ne w (0, 0, 1, 3) with rfl | hw0 + · rw [if_pos rfl] at hx + exact Module.End.mem_eigenspace_iff.mp (hz i hx) + · rcases eq_or_ne w (0, 0, -1, 3) with rfl | hw1 + · rw [if_neg hw0, if_pos rfl] at hx + exact Module.End.mem_eigenspace_iff.mp (ho i hx) + · rw [if_neg hw0, if_neg hw1, Submodule.mem_bot] at hx + subst hx + simp + piece_eq_bot := by + intro w hw + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hw + rw [if_neg hw.1, if_neg hw.2] + iSup_piece := by + have hrange : ∀ d : Fin n → (Fin 1 ⊕ Fin 3), + LinearMap.range (barH n d) = Submodule.span ℂ (Set.range (h.barHiggs d)) := fun d => by + rw [LinearMap.range_eq_map, ← (HiggsVec.orthonormBasis.toBasis.conj.dualBasis).span_eq, + Submodule.map_span, ← Set.range_comp] + rfl + have hmem : ∀ (d : Fin n → (Fin 1 ⊕ Fin 3)) (j : Fin 2), + h.barHiggs d j ∈ h.barHiggsSubmodule n := fun d j => + Submodule.mem_iSup_of_mem d ⟨HiggsVec.orthonormBasis.toBasis.conj.dualBasis j, rfl⟩ + refine le_antisymm (iSup_le fun w => ?_) ?_ + · rcases eq_or_ne w (0, 0, 1, 3) with rfl | hw0 + · rw [if_pos rfl] + exact iSup_le fun d => + (Submodule.span_singleton_le_iff_mem _ _).mpr (hmem d 0) + · rcases eq_or_ne w (0, 0, -1, 3) with rfl | hw1 + · rw [if_neg hw0, if_pos rfl] + exact iSup_le fun d => + (Submodule.span_singleton_le_iff_mem _ _).mpr (hmem d 1) + · rw [if_neg hw0, if_neg hw1] + exact bot_le + · rw [barHiggsSubmodule] + refine iSup_le fun d => ?_ + rw [hrange d, Submodule.span_le] + rintro _ ⟨j, rfl⟩ + fin_cases j + · refine Submodule.mem_iSup_of_mem (0, 0, 1, 3) ?_ + rw [if_pos rfl] + exact Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _) + · refine Submodule.mem_iSup_of_mem (0, 0, -1, 3) ?_ + rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _) + +/-! + +### A.5. The inner product of higges + +-/ + +open Lorentz.BoostWeight + +noncomputable def dot (x y : Fin 2 → B) : B := x 0 * y 0 + x 1 * y 1 + + +include h in +/-- The boost weights of the two factors of an isospin contraction add. -/ +lemma dot_mem_boostWeightSubmodule {i : Fin 3} {a b : ℤ} {x y : Fin 2 → B} + (hx : ∀ j, x j ∈ boostWeightSubmodule repLorentz i a) + (hy : ∀ j, y j ∈ boostWeightSubmodule repLorentz i b) : + dot x y ∈ boostWeightSubmodule repLorentz i (a + b) := by + refine mem_boostWeightSubmodule.2 fun t ht => ?_ + have hc : (algebraMap ℝ ℂ) t ≠ 0 := by simpa using ht + rw [dot, map_add, h.repLorentz_mul, h.repLorentz_mul, + mem_boostWeightSubmodule.1 (hx 0) t ht, mem_boostWeightSubmodule.1 (hy 0) t ht, + mem_boostWeightSubmodule.1 (hx 1) t ht, mem_boostWeightSubmodule.1 (hy 1) t ht, + smul_mul_smul_comm, smul_mul_smul_comm, ← zpow_add₀ hc, ← smul_add] + + +noncomputable def dotGaugeHiggs (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) + (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + B := h.higgs d1 0 * h.barHiggs d2 0 + h.higgs d1 1 * h.barHiggs d2 1 + +lemma dotGaugeHiggs_eq_dot (d1 : Fin n1 → _) (d2 : Fin n2 → _) : + h.dotGaugeHiggs d1 d2 = dot (h.higgs d1) (h.barHiggs d2) := by rfl + +lemma rep_dotGaugeHiggs (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + rep gaugeSU2Perm (h.dotGaugeHiggs d1 d2) = h.dotGaugeHiggs d1 d2 := by + rw [dotGaugeHiggs] + exact h.rep_gaugeSU2Perm_higgsBarHiggs_add d1 d2 + +lemma rep_dotGaugeHiggs_invariant (g : GaugeGroupI) (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) + (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) : + rep g (h.dotGaugeHiggs d1 d2) = h.dotGaugeHiggs d1 d2 := by + have hu : ((g⁻¹).toU1 : ℂ) * (starRingEnd ℂ) ((g⁻¹).toU1 : ℂ) = 1 := + Unitary.mul_star_self_of_mem (g⁻¹).toU1.2 + have hM : star ((g⁻¹).toSU2.1) * (g⁻¹).toSU2.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (g⁻¹).toSU2.2.1 + have hM00 := congrFun (congrFun hM 0) 0 + have hM01 := congrFun (congrFun hM 0) 1 + have hM10 := congrFun (congrFun hM 1) 0 + have hM11 := congrFun (congrFun hM 1) 1 + simp only [Matrix.mul_apply, Fin.sum_univ_two, Matrix.one_apply, star_eq_conjTranspose, + Matrix.conjTranspose_apply, reduceIte, Complex.star_def, + show ¬((0 : Fin 2) = 1) from by decide, + show ¬((1 : Fin 2) = 0) from by decide] at hM00 hM01 hM10 hM11 + have hM01' := congrArg (starRingEnd ℂ) hM01 + have hM10' := congrArg (starRingEnd ℂ) hM10 + simp only [map_add, map_mul, Complex.conj_conj, map_zero] at hM01' hM10' + have hu3 : ((g⁻¹).toU1 : ℂ) ^ 3 * (starRingEnd ℂ) (((g⁻¹).toU1 : ℂ) ^ 3) = 1 := by + rw [map_pow, ← mul_pow, hu, one_pow] + have key : ∀ a b : ℂ, (((g⁻¹).toU1 : ℂ) ^ 3 * a) * (starRingEnd ℂ) (((g⁻¹).toU1 : ℂ) ^ 3 * b) + = a * (starRingEnd ℂ) b := by + intro a b + rw [map_mul] + calc (((g⁻¹).toU1 : ℂ) ^ 3 * a) * ((starRingEnd ℂ) (((g⁻¹).toU1 : ℂ) ^ 3) + * (starRingEnd ℂ) b) + = (((g⁻¹).toU1 : ℂ) ^ 3 * (starRingEnd ℂ) (((g⁻¹).toU1 : ℂ) ^ 3)) + * (a * (starRingEnd ℂ) b) := by ring + _ = a * (starRingEnd ℂ) b := by rw [hu3, one_mul] + rw [dotGaugeHiggs, map_add, h.rep_mul, h.rep_mul, h.rep_higgsComponent, + h.rep_barHiggsComponent, h.rep_higgsComponent, h.rep_barHiggsComponent] + simp only [Fin.sum_univ_two, add_mul, mul_add, smul_mul_smul_comm, key] + match_scalars + · linear_combination hM00 + · linear_combination hM10' + · linear_combination hM01' + · linear_combination hM11 + +/-! +### E + +An aside on derivatives and +boost weights (to be moved). + +-/ + +lemma succ_deriv_span {n : ℕ} (f : (Fin n.succ → (Fin 1 ⊕ Fin 3)) → B) : + ⨆ d, ℂ ∙ f d = ⨆ μ : Fin 1 ⊕ Fin 3, ⨆ d, ℂ ∙ f (Fin.cons μ d) := by + refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun μ => iSup_le fun d => ?_) + · exact le_iSup_of_le (d 0) (le_iSup_of_le (Fin.tail d) (by rw [Fin.cons_self_tail])) + · exact le_iSup (fun d => ℂ ∙ f d) (Fin.cons μ d) + +lemma succ_dervi_span_eq_lightCone {n : ℕ} (f : (Fin n.succ → (Fin 1 ⊕ Fin 3)) → B) + (i : Fin 3) : + ⨆ d, ℂ ∙ f d = (⨆ d, ℂ ∙ (f (Fin.cons (Sum.inl 0) d) - f (Fin.cons (Sum.inr i) d))) ⊔ + (⨆ d, ℂ ∙ (f (Fin.cons (Sum.inl 0) d) + f (Fin.cons (Sum.inr i) d))) + ⊔ (⨆ d, ℂ ∙ f (Fin.cons (Sum.inr (i + 1)) d)) + ⊔ (⨆ d, ℂ ∙ f (Fin.cons (Sum.inr (i + 2)) d)) := by + have hcomb : ∀ (A C : B) (S : Submodule ℂ B), A - C ∈ S → A + C ∈ S → A ∈ S ∧ C ∈ S := by + refine fun A C S h1 h2 => ⟨?_, ?_⟩ + · rw [show A = (2⁻¹ : ℂ) • ((A - C) + (A + C)) from by module] + exact Submodule.smul_mem _ _ (add_mem h1 h2) + · rw [show C = (2⁻¹ : ℂ) • ((A + C) - (A - C)) from by module] + exact Submodule.smul_mem _ _ (sub_mem h2 h1) + have hax : ∀ a b : Fin 3, b = a ∨ b = a + 1 ∨ b = a + 2 := by decide + refine le_antisymm (le_trans (le_of_eq (succ_deriv_span f)) ?_) + (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) + · refine iSup_le fun μ => iSup_le fun d => ?_ + rcases μ with a | j + · rw [Subsingleton.elim a 0, Submodule.span_singleton_le_iff_mem] + refine (hcomb (f (Fin.cons (Sum.inl 0) d)) (f (Fin.cons (Sum.inr i) d)) _ ?_ ?_).1 + · exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + · exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + · rcases hax i j with hj | hj | hj <;> rw [hj, Submodule.span_singleton_le_iff_mem] + · refine (hcomb (f (Fin.cons (Sum.inl 0) d)) (f (Fin.cons (Sum.inr i) d)) _ ?_ ?_).2 + · exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + · exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + · exact Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))) + · exact Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact sub_mem + (Submodule.mem_iSup_of_mem (Fin.cons (Sum.inl 0) d) (Submodule.mem_span_singleton_self _)) + (Submodule.mem_iSup_of_mem (Fin.cons (Sum.inr i) d) (Submodule.mem_span_singleton_self _)) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact add_mem + (Submodule.mem_iSup_of_mem (Fin.cons (Sum.inl 0) d) (Submodule.mem_span_singleton_self _)) + (Submodule.mem_iSup_of_mem (Fin.cons (Sum.inr i) d) (Submodule.mem_span_singleton_self _)) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact Submodule.mem_iSup_of_mem (Fin.cons (Sum.inr (i + 1)) d) + (Submodule.mem_span_singleton_self _) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact Submodule.mem_iSup_of_mem (Fin.cons (Sum.inr (i + 2)) d) + (Submodule.mem_span_singleton_self _) + +structure IsDerivativeCollection {W} [AddCommGroup W] [Module ℂ W] + (repW : Representation ℂ SL(2,ℂ) W) (α : ℕ) + (f : (num : Fin α → ℕ) → (Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) → W →ₗ[ℂ] B) where + /-- The symbol map intertwines the Lorentz action on `W` with the one on `B`, up to the + rotation of its derivative indices: each index is a Lorentz vector index. The partition + `num` of the indices among the `α` factors is a spectator — the rotation does not see + how the indices are grouped — so the law is one sum over one product. -/ + repLorentz_equiv : ∀ (g : SL(2,ℂ)) (num : Fin α → ℕ) + (d : Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) (w : W), + repLorentz g (f num d w) = ∑ (a : Fin (∑ i, num i) → Fin 1 ⊕ Fin 3), + (∏ (j : Fin (∑ i, num i)), (((SL2C.toLorentzGroup g).1 (a j) (d j) : ℝ) : ℂ)) • + (f num a (repW g w)) + +namespace IsDerivativeCollection + +variable {W} [AddCommGroup W] [Module ℂ W] {repW : Representation ℂ SL(2,ℂ) W} + +/-- **One shape's worth of the rotation law**: every derivative index of `F` is a Lorentz + vector index. This is all the boost-weight development below uses, so it is taken as a + hypothesis; `IsDerivativeCollection.rotatesIndices` supplies it for each partition. -/ +abbrev RotatesIndices (repW : Representation ℂ SL(2,ℂ) W) + (repLorentz : Representation ℂ SL(2,ℂ) B) {n : ℕ} + (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) : Prop := + ∀ (g : SL(2,ℂ)) (d : Fin n → Fin 1 ⊕ Fin 3) (w : W), + repLorentz g (F d w) = ∑ (a : Fin n → Fin 1 ⊕ Fin 3), + (∏ (j : Fin n), (((SL2C.toLorentzGroup g).1 (a j) (d j) : ℝ) : ℂ)) • F a (repW g w) + + +/-- The boost-weight decomposition of the symbols carrying no derivatives: with no Lorentz + index to rotate, the symbol map transports the decomposition of `W` unchanged. This is + the `n = 0` case of `boostDecomp`. -/ +noncomputable def boostDecompZero (F : (Fin 0 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) + (hF : RotatesIndices repW repLorentz F) (i : Fin 3) + (hw : WeightDecomposition (K := ℂ) repW i ⊤) : + WeightDecomposition repLorentz i (⨆ d : Fin 0 → Fin 1 ⊕ Fin 3, (F d).range) where + piece k := (hw.piece k).map (F ![]) + supp := hw.supp + piece_le k := by + have hf0 : ∀ a : Fin 0 → Fin 1 ⊕ Fin 3, F a = F ![] := fun a => by + rw [Subsingleton.elim a ![]] + rintro _ ⟨w, hwmem, rfl⟩ t ht + rw [hF] + simp only [Finset.univ_unique, Finset.sum_singleton, Finset.univ_eq_empty, + Finset.prod_empty, one_smul] + rw [hw.piece_le k hwmem t ht, map_smul, hf0] + piece_eq_bot k hk := by rw [hw.piece_eq_bot k hk, Submodule.map_bot] + iSup_piece := by + rw [← Submodule.map_iSup, hw.iSup_piece, Submodule.map_top] + exact le_antisymm (le_iSup (fun d => (F d).range) ![]) + (iSup_le fun d => le_of_eq (by rw [Subsingleton.elim d ![]])) + +/-- The four light-cone directions along the `i`-th axis, written as coefficient vectors on + the coordinate directions: `D₀ - Dᵢ`, `D₀ + Dᵢ`, and the two transverse directions. -/ +def lightConeCoeff (i : Fin 3) (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3) : ℂ := + if κ = 0 then (if μ = Sum.inl 0 then 1 else if μ = Sum.inr i then -1 else 0) + else if κ = 1 then (if μ = Sum.inl 0 then 1 else if μ = Sum.inr i then 1 else 0) + else if κ = 2 then (if μ = Sum.inr (i + 1) then 1 else 0) + else (if μ = Sum.inr (i + 2) then 1 else 0) + +/-- The boost weight carried by each light-cone direction: `+2` for `D₀ - Dᵢ`, `-2` for + `D₀ + Dᵢ`, and `0` for the two transverse directions. -/ +def lightConeWeight (κ : Fin 4) : ℤ := if κ = 0 then 2 else if κ = 1 then -2 else 0 + +/-- **The light-cone directions are eigenvectors of the boost.** Along the `i`-th axis + `D₀ - Dᵢ` is scaled by `t²`, `D₀ + Dᵢ` by `t⁻²`, and the two transverse directions are + fixed. -/ +lemma sum_boostAxis_lightConeCoeff (i : Fin 3) (κ : Fin 4) (ν : Fin 1 ⊕ Fin 3) + {t : ℝ} (ht : t ≠ 0) : + ∑ μ : Fin 1 ⊕ Fin 3, + (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 ν μ : ℝ) : ℂ) * lightConeCoeff i κ μ + = ((t : ℝ) : ℂ) ^ (lightConeWeight κ) * lightConeCoeff i κ ν := by + have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + rw [show SL2C.toLorentzGroup (SL2C.boostAxis i t ht) = LorentzGroup.boostAxis i t ht from rfl] + rcases ν with a | j + · rw [Subsingleton.elim a 0] + fin_cases i <;> fin_cases κ + all_goals + simp [lightConeCoeff, lightConeWeight, Fintype.sum_sum_type, + LorentzGroup.boostAxis_apply] + all_goals try field_simp + all_goals try ring + · fin_cases i <;> fin_cases j <;> fin_cases κ + all_goals + simp [lightConeCoeff, lightConeWeight, Fintype.sum_sum_type, + LorentzGroup.boostAxis_apply] + all_goals try field_simp + all_goals try ring + +/-- The coordinate directions written back in the light-cone basis: `D₀` and `Dᵢ` are the + half-sum and half-difference of `D₀ ∓ Dᵢ`, and the transverse directions are themselves. -/ +noncomputable def lightConeCoeffInv (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : ℂ := + if μ = Sum.inl 0 then (if κ = 0 then 2⁻¹ else if κ = 1 then 2⁻¹ else 0) + else if μ = Sum.inr i then (if κ = 0 then -2⁻¹ else if κ = 1 then 2⁻¹ else 0) + else if μ = Sum.inr (i + 1) then (if κ = 2 then 1 else 0) + else (if κ = 3 then 1 else 0) + +/-- The inverse coefficient toward the first transverse direction vanishes off it. -/ +lemma lightConeCoeffInv_two_eq_zero (i : Fin 3) {μ : Fin 1 ⊕ Fin 3} + (hμ : μ ≠ Sum.inr (i + 1)) : lightConeCoeffInv i μ 2 = 0 := by + simp [lightConeCoeffInv, hμ] + +/-- The inverse coefficient toward the second transverse direction vanishes off it. -/ +lemma lightConeCoeffInv_three_eq_zero (i : Fin 3) {μ : Fin 1 ⊕ Fin 3} + (hμ : μ ≠ Sum.inr (i + 2)) : lightConeCoeffInv i μ 3 = 0 := by + rcases μ with a | m + · rw [Subsingleton.elim a 0] + simp [lightConeCoeffInv] + · fin_cases i <;> fin_cases m <;> simp_all [lightConeCoeffInv] + +/-- The inverse coefficient of the first transverse direction is supported on its own + light-cone index. -/ +lemma lightConeCoeffInv_transverse_one_eq_zero (i : Fin 3) {μ : Fin 1 ⊕ Fin 3} {κ : Fin 4} + (hμ : μ = Sum.inr (i + 1)) (hκ : κ ≠ 2) : lightConeCoeffInv i μ κ = 0 := by + subst hμ + fin_cases i <;> fin_cases κ <;> simp_all [lightConeCoeffInv] + +/-- The light-cone basis is a basis: the two coefficient matrices are inverse. -/ +lemma sum_lightConeCoeffInv_mul (i : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : + ∑ κ : Fin 4, lightConeCoeffInv i μ κ * lightConeCoeff i κ ν = if μ = ν then 1 else 0 := by + rcases μ with a | j + · rw [Subsingleton.elim a 0] + rcases ν with a' | j' + · rw [Subsingleton.elim a' 0] + fin_cases i <;> + simp [lightConeCoeff, lightConeCoeffInv, Fin.sum_univ_four] <;> norm_num + · fin_cases i <;> fin_cases j' <;> + simp [lightConeCoeff, lightConeCoeffInv, Fin.sum_univ_four] + · rcases ν with a' | j' + · rw [Subsingleton.elim a' 0] + fin_cases i <;> fin_cases j <;> + simp [lightConeCoeff, lightConeCoeffInv, Fin.sum_univ_four] + · fin_cases i <;> fin_cases j <;> fin_cases j' <;> + simp [lightConeCoeff, lightConeCoeffInv, Fin.sum_univ_four] <;> norm_num + +/-- The scalar behind `lightConeDeriv_mem`: the boost acts on a light-cone multi-index + slot by slot, so the product of the per-slot eigenvalues factors out. -/ +lemma sum_prod_lightConeCoeff (i : Fin 3) {n : ℕ} (c : Fin n → Fin 4) + (a : Fin n → Fin 1 ⊕ Fin 3) {t : ℝ} (ht : t ≠ 0) : + ∑ d : Fin n → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) * + (∏ j, (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) (d j) : ℝ) : ℂ)) + = ((t : ℝ) : ℂ) ^ (∑ j, lightConeWeight (c j)) * ∏ j, lightConeCoeff i (c j) (a j) := by + have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + have hzpow : ∀ (s : Finset (Fin n)) (g : Fin n → ℤ), + ∏ j ∈ s, ((t : ℝ) : ℂ) ^ (g j) = ((t : ℝ) : ℂ) ^ (∑ j ∈ s, g j) := by + intro s g + induction s using Finset.induction with + | empty => simp + | insert a s ha ih => rw [Finset.prod_insert ha, Finset.sum_insert ha, ih, zpow_add₀ htc] + calc ∑ d : Fin n → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) * + (∏ j, (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) (d j) : ℝ) : ℂ)) + = ∑ d : Fin n → Fin 1 ⊕ Fin 3, ∏ j, (lightConeCoeff i (c j) (d j) * + (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) (d j) : ℝ) : ℂ)) := + Finset.sum_congr rfl fun d _ => (Finset.prod_mul_distrib).symm + _ = ∏ j, ∑ μ : Fin 1 ⊕ Fin 3, (lightConeCoeff i (c j) μ * + (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) μ : ℝ) : ℂ)) := by + rw [Finset.prod_univ_sum, Fintype.piFinset_univ] + _ = ∏ j, (((t : ℝ) : ℂ) ^ (lightConeWeight (c j)) * lightConeCoeff i (c j) (a j)) := by + refine Finset.prod_congr rfl fun j _ => ?_ + simp_rw [mul_comm (lightConeCoeff i (c j) _)] + exact sum_boostAxis_lightConeCoeff i (c j) (a j) ht + _ = (∏ j, ((t : ℝ) : ℂ) ^ (lightConeWeight (c j))) * ∏ j, lightConeCoeff i (c j) (a j) := + Finset.prod_mul_distrib + _ = ((t : ℝ) : ℂ) ^ (∑ j, lightConeWeight (c j)) * ∏ j, lightConeCoeff i (c j) (a j) := by + rw [hzpow] + +/-- **The symbol with its derivative indices in the light-cone basis.** Each slot `j` of the + multi-index carries a light-cone direction `c j` instead of a coordinate direction, so the + symbol is an eigenvector of the boost along the `i`-th axis, of weight + `∑ j, lightConeWeight (c j)`. -/ +noncomputable def lightConeDeriv {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) + (i : Fin 3) (c : Fin n → Fin 4) : W →ₗ[ℂ] B := + ∑ d : Fin n → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) • F d + +/-- **A one-slot light-cone symbol**, written out as a combination of coordinate symbols. -/ +lemma lightConeDeriv_single (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) (κ : Fin 4) : + lightConeDeriv F i ![κ] = ∑ μ : Fin 1 ⊕ Fin 3, lightConeCoeff i κ μ • F ![μ] := by + rw [lightConeDeriv] + refine Fintype.sum_equiv (Equiv.funUnique (Fin 1) (Fin 1 ⊕ Fin 3)) _ _ fun d => ?_ + have hd : d = ![d 0] := by + funext j + fin_cases j + rfl + simp only [Fin.prod_univ_one, Matrix.cons_val_zero, Equiv.funUnique_apply, + Fin.default_eq_zero] + rw [← hd] + +/-- The light-cone combination `D₀ - Dᵢ` on one slot. -/ +lemma lightConeDeriv_zero (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![0] = F ![Sum.inl 0] - F ![Sum.inr i] := by + rw [lightConeDeriv_single] + fin_cases i <;> + simp [lightConeCoeff, Fintype.sum_sum_type] <;> module + +/-- The light-cone combination `D₀ + Dᵢ` on one slot. -/ +lemma lightConeDeriv_one (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![1] = F ![Sum.inl 0] + F ![Sum.inr i] := by + rw [lightConeDeriv_single] + fin_cases i <;> + simp [lightConeCoeff, Fintype.sum_sum_type] + +/-- The first transverse direction on one slot. -/ +lemma lightConeDeriv_two (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![2] = F ![Sum.inr (i + 1)] := by + rw [lightConeDeriv_single] + fin_cases i <;> + simp [lightConeCoeff] + +/-- The second transverse direction on one slot. -/ +lemma lightConeDeriv_three (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![3] = F ![Sum.inr (i + 2)] := by + rw [lightConeDeriv_single] + fin_cases i <;> + simp [lightConeCoeff] + +/-- **A two-slot light-cone symbol**, written out as a double sum over coordinate + symbols. -/ +lemma lightConeDeriv_pair (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) + (κ₀ κ₁ : Fin 4) : + lightConeDeriv F i ![κ₀, κ₁] = ∑ μ : Fin 1 ⊕ Fin 3, ∑ ν : Fin 1 ⊕ Fin 3, + (lightConeCoeff i κ₀ μ * lightConeCoeff i κ₁ ν) • F ![μ, ν] := + calc lightConeDeriv F i ![κ₀, κ₁] + = ∑ p : (Fin 1 ⊕ Fin 3) × (Fin 1 ⊕ Fin 3), + (lightConeCoeff i κ₀ p.1 * lightConeCoeff i κ₁ p.2) • F ![p.1, p.2] := by + rw [lightConeDeriv] + refine Fintype.sum_equiv (piFinTwoEquiv fun _ => Fin 1 ⊕ Fin 3) _ _ fun d => ?_ + have hd : ![d 0, d 1] = d := by + funext j + fin_cases j <;> rfl + rw [Fin.prod_univ_two] + simp only [piFinTwoEquiv_apply, Matrix.cons_val_zero, Matrix.cons_val_one, hd] + _ = _ := Fintype.sum_prod_type _ + +/-- The `(D₀ - Dᵢ)(D₀ + Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_zero_one (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![0, 1] = F ![Sum.inl 0, Sum.inl 0] + F ![Sum.inl 0, Sum.inr i] + - F ![Sum.inr i, Sum.inl 0] - F ![Sum.inr i, Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul] + module + +/-- The `(D₀ + Dᵢ)(D₀ - Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_one_zero (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![1, 0] = F ![Sum.inl 0, Sum.inl 0] - F ![Sum.inl 0, Sum.inr i] + + F ![Sum.inr i, Sum.inl 0] - F ![Sum.inr i, Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul, neg_ite] + module + +/-- Both slots on the first transverse direction. -/ +lemma lightConeDeriv_pair_two_two (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![2, 2] = F ![Sum.inr (i + 1), Sum.inr (i + 1)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff] + +/-- The first then second transverse directions. -/ +lemma lightConeDeriv_pair_two_three (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![2, 3] = F ![Sum.inr (i + 1), Sum.inr (i + 2)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff] + +/-- The second then first transverse directions. -/ +lemma lightConeDeriv_pair_three_two (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![3, 2] = F ![Sum.inr (i + 2), Sum.inr (i + 1)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff] + +/-- Both slots on the second transverse direction. -/ +lemma lightConeDeriv_pair_three_three (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![3, 3] = F ![Sum.inr (i + 2), Sum.inr (i + 2)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff] + +/-- The `(D₀ - Dᵢ)(D₀ - Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_zero_zero (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![0, 0] = F ![Sum.inl 0, Sum.inl 0] - F ![Sum.inl 0, Sum.inr i] + - F ![Sum.inr i, Sum.inl 0] + F ![Sum.inr i, Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul, neg_ite] + module + +/-- The `(D₀ + Dᵢ)(D₀ + Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_one_one (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![1, 1] = F ![Sum.inl 0, Sum.inl 0] + F ![Sum.inl 0, Sum.inr i] + + F ![Sum.inr i, Sum.inl 0] + F ![Sum.inr i, Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul] + module + +/-- The `(D₀ - Dᵢ)` then second transverse slot pair. -/ +lemma lightConeDeriv_pair_zero_three (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![0, 3] = F ![Sum.inl 0, Sum.inr (i + 2)] + - F ![Sum.inr i, Sum.inr (i + 2)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_ite_eq', ite_smul] + module + +/-- The second transverse then `(D₀ - Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_three_zero (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![3, 0] = F ![Sum.inr (i + 2), Sum.inl 0] + - F ![Sum.inr (i + 2), Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul, neg_ite] + module + +/-- The `(D₀ + Dᵢ)` then second transverse slot pair. -/ +lemma lightConeDeriv_pair_one_three (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![1, 3] = F ![Sum.inl 0, Sum.inr (i + 2)] + + F ![Sum.inr i, Sum.inr (i + 2)] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_ite_eq', ite_smul] + +/-- The second transverse then `(D₀ + Dᵢ)` slot pair. -/ +lemma lightConeDeriv_pair_three_one (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + lightConeDeriv F i ![3, 1] = F ![Sum.inr (i + 2), Sum.inl 0] + + F ![Sum.inr (i + 2), Sum.inr i] := by + rw [lightConeDeriv_pair] + simp [lightConeCoeff, Fintype.sum_sum_type, Finset.sum_add_distrib, Finset.sum_ite_eq', + ite_smul] + +/-- **The two-slot light-cone indices of weight zero**: the two mixed null pairs and the + four transverse pairs. -/ +lemma iSup_range_lightConeDeriv_pair_weight_zero + (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = (0 : ℤ)), + LinearMap.range (lightConeDeriv F i c)) + = ((LinearMap.range (lightConeDeriv F i ![0, 1]) ⊔ + LinearMap.range (lightConeDeriv F i ![1, 0])) ⊔ + (LinearMap.range (lightConeDeriv F i ![2, 2]) ⊔ + LinearMap.range (lightConeDeriv F i ![2, 3]))) ⊔ + (LinearMap.range (lightConeDeriv F i ![3, 2]) ⊔ + LinearMap.range (lightConeDeriv F i ![3, 3])) := by + refine le_antisymm (iSup₂_le fun c hc => ?_) + (sup_le (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) (sup_le ?_ ?_)) + · obtain ⟨κ₀, κ₁, rfl⟩ : ∃ κ₀ κ₁, c = ![κ₀, κ₁] := + ⟨c 0, c 1, funext fun j => by fin_cases j <;> rfl⟩ + rw [Fin.sum_univ_two] at hc + fin_cases κ₀ + · fin_cases κ₁ + · exact absurd hc (by decide) + · exact le_sup_of_le_left (le_sup_of_le_left le_sup_left) + · exact absurd hc (by decide) + · exact absurd hc (by decide) + · fin_cases κ₁ + · exact le_sup_of_le_left (le_sup_of_le_left le_sup_right) + · exact absurd hc (by decide) + · exact absurd hc (by decide) + · exact absurd hc (by decide) + · fin_cases κ₁ + · exact absurd hc (by decide) + · exact absurd hc (by decide) + · exact le_sup_of_le_left (le_sup_of_le_right le_sup_left) + · exact le_sup_of_le_left (le_sup_of_le_right le_sup_right) + · fin_cases κ₁ + · exact absurd hc (by decide) + · exact absurd hc (by decide) + · exact le_sup_of_le_right le_sup_left + · exact le_sup_of_le_right le_sup_right + · exact le_iSup₂_of_le ![0, 1] (by decide) le_rfl + · exact le_iSup₂_of_le ![1, 0] (by decide) le_rfl + · exact le_iSup₂_of_le ![2, 2] (by decide) le_rfl + · exact le_iSup₂_of_le ![2, 3] (by decide) le_rfl + · exact le_iSup₂_of_le ![3, 2] (by decide) le_rfl + · exact le_iSup₂_of_le ![3, 3] (by decide) le_rfl + +/-- **The weight-zero light-cone pairs avoiding the mixed transverse indices**: the two + null pairs and the two repeated transverse pairs. -/ +lemma iSup_range_lightConeDeriv_pair_weight_zero_notMixed + (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = (0 : ℤ) ∧ + ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)), + LinearMap.range (lightConeDeriv F i c)) + = ((LinearMap.range (lightConeDeriv F i ![0, 1]) ⊔ + LinearMap.range (lightConeDeriv F i ![1, 0])) ⊔ + (LinearMap.range (lightConeDeriv F i ![2, 2]) ⊔ + LinearMap.range (lightConeDeriv F i ![3, 3]))) := by + refine le_antisymm (iSup₂_le fun c hc => ?_) + (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) + · obtain ⟨κ₀, κ₁, rfl⟩ : ∃ κ₀ κ₁, c = ![κ₀, κ₁] := + ⟨c 0, c 1, funext fun j => by fin_cases j <;> rfl⟩ + obtain ⟨hw, h23, h32⟩ := hc + rw [Fin.sum_univ_two] at hw + fin_cases κ₀ + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact le_sup_of_le_left le_sup_left + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · fin_cases κ₁ + · exact le_sup_of_le_left le_sup_right + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact le_sup_of_le_right le_sup_left + · exact absurd (by decide) h23 + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact absurd (by decide) h32 + · exact le_sup_of_le_right le_sup_right + · exact le_iSup₂_of_le ![0, 1] (by decide) le_rfl + · exact le_iSup₂_of_le ![1, 0] (by decide) le_rfl + · exact le_iSup₂_of_le ![2, 2] (by decide) le_rfl + · exact le_iSup₂_of_le ![3, 3] (by decide) le_rfl + +/-- **The weight-zero light-cone pairs whose slots hit the first transverse direction + together or not at all**: the two null pairs and the two repeated transverse pairs. -/ +lemma iSup_range_lightConeDeriv_pair_weight_zero_sync + (F : (Fin 2 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = (0 : ℤ) ∧ + ((c 0 = 2) ↔ (c 1 = 2))), + LinearMap.range (lightConeDeriv F i c)) + = ((LinearMap.range (lightConeDeriv F i ![0, 1]) ⊔ + LinearMap.range (lightConeDeriv F i ![1, 0])) ⊔ + (LinearMap.range (lightConeDeriv F i ![2, 2]) ⊔ + LinearMap.range (lightConeDeriv F i ![3, 3]))) := by + refine le_antisymm (iSup₂_le fun c hc => ?_) + (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) + · obtain ⟨κ₀, κ₁, rfl⟩ : ∃ κ₀ κ₁, c = ![κ₀, κ₁] := + ⟨c 0, c 1, funext fun j => by fin_cases j <;> rfl⟩ + obtain ⟨hw, hsync⟩ := hc + rw [Fin.sum_univ_two] at hw + fin_cases κ₀ + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact le_sup_of_le_left le_sup_left + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · fin_cases κ₁ + · exact le_sup_of_le_left le_sup_right + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact le_sup_of_le_right le_sup_left + · exact absurd hsync (by decide) + · fin_cases κ₁ + · exact absurd hw (by decide) + · exact absurd hw (by decide) + · exact absurd hsync (by decide) + · exact le_sup_of_le_right le_sup_right + · exact le_iSup₂_of_le ![0, 1] (by decide) le_rfl + · exact le_iSup₂_of_le ![1, 0] (by decide) le_rfl + · exact le_iSup₂_of_le ![2, 2] (by decide) le_rfl + · exact le_iSup₂_of_le ![3, 3] (by decide) le_rfl + +/-- **The one-slot light-cone symbols of weight zero** are the two transverse directions: + the join of the weight-zero ranges on a single slot is the join of the ranges of the two + transverse symbols. -/ +lemma iSup_range_lightConeDeriv_single_weight_zero + (F : (Fin 1 → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) : + (⨆ (c : Fin 1 → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = (0 : ℤ)), + LinearMap.range (lightConeDeriv F i c)) + = LinearMap.range (F ![Sum.inr (i + 1)]) ⊔ LinearMap.range (F ![Sum.inr (i + 2)]) := by + refine le_antisymm (iSup₂_le fun c hc => ?_) (sup_le ?_ ?_) + · obtain ⟨κ, rfl⟩ : ∃ κ, c = ![κ] := ⟨c 0, funext fun j => by fin_cases j; rfl⟩ + rw [Fin.sum_univ_one] at hc + fin_cases κ + · simp [lightConeWeight] at hc + · simp [lightConeWeight] at hc + · exact le_sup_of_le_left (le_of_eq (congrArg LinearMap.range (lightConeDeriv_two F i))) + · exact le_sup_of_le_right (le_of_eq (congrArg LinearMap.range (lightConeDeriv_three F i))) + · exact le_iSup₂_of_le ![2] (by simp [lightConeWeight]) + (le_of_eq (by rw [lightConeDeriv_two])) + · exact le_iSup₂_of_le ![3] (by simp [lightConeWeight]) + (le_of_eq (by rw [lightConeDeriv_three])) + +/-- The scalar behind `f_eq_sum_lightConeDeriv`: the two coefficient matrices are inverse + slot by slot, hence inverse on multi-indices. -/ +lemma sum_prod_lightConeCoeffInv (i : Fin 3) {n : ℕ} (d e : Fin n → Fin 1 ⊕ Fin 3) : + ∑ c : Fin n → Fin 4, (∏ j, lightConeCoeffInv i (d j) (c j)) * + (∏ j, lightConeCoeff i (c j) (e j)) = if d = e then 1 else 0 := by + calc ∑ c : Fin n → Fin 4, (∏ j, lightConeCoeffInv i (d j) (c j)) * + (∏ j, lightConeCoeff i (c j) (e j)) + = ∑ c : Fin n → Fin 4, + ∏ j, (lightConeCoeffInv i (d j) (c j) * lightConeCoeff i (c j) (e j)) := + Finset.sum_congr rfl fun c _ => (Finset.prod_mul_distrib).symm + _ = ∏ j, ∑ κ : Fin 4, (lightConeCoeffInv i (d j) κ * lightConeCoeff i κ (e j)) := by + rw [Finset.prod_univ_sum, Fintype.piFinset_univ] + _ = ∏ j, (if d j = e j then (1 : ℂ) else 0) := + Finset.prod_congr rfl fun j _ => sum_lightConeCoeffInv_mul i (d j) (e j) + _ = if d = e then 1 else 0 := by + by_cases hde : d = e + · subst hde + simp + · rw [if_neg hde] + obtain ⟨j, hj⟩ := Function.ne_iff.1 hde + exact Finset.prod_eq_zero (Finset.mem_univ j) (if_neg hj) + +/-- **The coordinate symbols in the light-cone basis.** The change of basis is invertible, + so the two families span the same submodule. -/ +lemma eq_sum_lightConeDeriv {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) (i : Fin 3) + (d : Fin n → Fin 1 ⊕ Fin 3) : + F d = ∑ c : Fin n → Fin 4, + (∏ j, lightConeCoeffInv i (d j) (c j)) • lightConeDeriv F i c := by + simp only [lightConeDeriv, Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + simp only [← Finset.sum_smul, sum_prod_lightConeCoeffInv i d, ite_smul, one_smul, zero_smul, + Finset.sum_ite_eq, Finset.mem_univ, if_true] + +/-- **The light-cone symbols have definite boost weight.** Each derivative slot contributes + the weight of its light-cone direction, on top of the weight the argument carries in + `W`. -/ +lemma lightConeDeriv_mem {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) + (hF : RotatesIndices repW repLorentz F) + (i : Fin 3) (c : Fin n → Fin 4) {b : ℤ} {w : W} + (hwm : w ∈ boostWeightSubmodule repW i b) : + lightConeDeriv F i c w ∈ + boostWeightSubmodule repLorentz i ((∑ j, lightConeWeight (c j)) + b) := by + intro t ht + have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + have key : repLorentz (SL2C.boostAxis i t ht) (lightConeDeriv F i c w) + = ((t : ℝ) : ℂ) ^ (∑ j, lightConeWeight (c j)) • + lightConeDeriv F i c (repW (SL2C.boostAxis i t ht) w) := by + have hstep : ∀ x : Fin n → Fin 1 ⊕ Fin 3, + (∏ j, lightConeCoeff i (c j) (x j)) • repLorentz (SL2C.boostAxis i t ht) (F x w) + = ∑ a : Fin n → Fin 1 ⊕ Fin 3, + ((∏ j, lightConeCoeff i (c j) (x j)) * + (∏ j, (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) (x j) : ℝ) : ℂ))) • + F a (repW (SL2C.boostAxis i t ht) w) := by + intro x + rw [hF, Finset.smul_sum] + exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _ + simp only [lightConeDeriv, LinearMap.coe_sum, Finset.sum_apply, LinearMap.smul_apply, + map_sum, map_smul] + rw [Finset.smul_sum] + simp only [hstep] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [← Finset.sum_smul, smul_smul] + congr 1 + exact sum_prod_lightConeCoeff i c a ht + rw [key, hwm t ht, map_smul, smul_smul, + show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl, ← zpow_add₀ htc] + +/-- The range of a light-cone symbol over a Lorentz-scalar argument lies in the + boost-weight space of its total slot weight. -/ +lemma range_lightConeDeriv_le {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → ℂ →ₗ[ℂ] B) + (hF : RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz F) + (i : Fin 3) (c : Fin n → Fin 4) : + LinearMap.range (lightConeDeriv F i c) ≤ + boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by + rintro x ⟨w, rfl⟩ + simpa using lightConeDeriv_mem F hF i c (b := 0) (w := w) + (mem_boostWeightSubmodule.2 fun t ht => by simp) + +/-- The range of a light-cone symbol lies in the join of the coordinate ranges. -/ +lemma range_lightConeDeriv_le_iSup_range {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) + (i : Fin 3) (c : Fin n → Fin 4) : + LinearMap.range (lightConeDeriv F i c) ≤ ⨆ d, LinearMap.range (F d) := by + rintro x ⟨w, rfl⟩ + rw [lightConeDeriv] + simp only [LinearMap.coe_sum, Finset.sum_apply, LinearMap.smul_apply] + exact sum_mem fun d _ => Submodule.smul_mem _ _ + (Submodule.mem_iSup_of_mem d (LinearMap.mem_range_self _ w)) + +/-- **The value of a two-slot light-cone symbol at `1`**, for a family over `ℂ`. -/ +noncomputable def lightConeDot (F : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ →ₗ[ℂ] B) (i : Fin 3) + (c : Fin 2 → Fin 4) : B := + lightConeDeriv F i c (1 : ℂ) + +/-- A light-cone symbol value is a boost eigenvector of its total slot weight. -/ +lemma lightConeDot_mem (F : (Fin 2 → Fin 1 ⊕ Fin 3) → ℂ →ₗ[ℂ] B) + (hF : RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz F) (i : Fin 3) + (c : Fin 2 → Fin 4) {k : ℤ} (hk : (∑ j, lightConeWeight (c j)) = k) : + lightConeDot F i c ∈ boostWeightSubmodule repLorentz i k := + hk ▸ range_lightConeDeriv_le (n := 2) F hF i c ⟨1, rfl⟩ + +/-- **The boost-weight decomposition of the symbols carrying `n` derivatives.** The + multi-index is read in the light-cone basis: a slot of type `c j` contributes + `lightConeWeight (c j)` — `+2` for `D₀ - Dᵢ`, `-2` for `D₀ + Dᵢ`, `0` for the two + transverse directions — on top of the weight the argument already carries in `W`. -/ +noncomputable def boostDecomp {n : ℕ} (F : (Fin n → Fin 1 ⊕ Fin 3) → W →ₗ[ℂ] B) + (hF : RotatesIndices repW repLorentz F) + (i : Fin 3) (hw : WeightDecomposition (K := ℂ) repW i ⊤) : + WeightDecomposition repLorentz i (⨆ d : Fin n → Fin 1 ⊕ Fin 3, (F d).range) where + piece k := ⨆ c : Fin n → Fin 4, + (hw.piece (k - ∑ j, lightConeWeight (c j))).map (lightConeDeriv F i c) + supp := (Finset.univ ×ˢ hw.supp).image + fun p : (Fin n → Fin 4) × ℤ => (∑ j, lightConeWeight (p.1 j)) + p.2 + piece_le k := by + refine iSup_le fun c => ?_ + rintro _ ⟨w, hwmem, rfl⟩ + have hmem := lightConeDeriv_mem F hF i c (hw.piece_le _ hwmem) + rwa [show (∑ j, lightConeWeight (c j)) + (k - ∑ j, lightConeWeight (c j)) = k from by ring] + at hmem + piece_eq_bot k hk := by + refine le_antisymm (iSup_le fun c => ?_) bot_le + have hb : k - (∑ j, lightConeWeight (c j)) ∉ hw.supp := fun hb => + hk (Finset.mem_image.2 ⟨(c, k - ∑ j, lightConeWeight (c j)), + Finset.mem_product.2 ⟨Finset.mem_univ c, hb⟩, by dsimp only; ring⟩) + rw [hw.piece_eq_bot _ hb, Submodule.map_bot] + iSup_piece := by + have hc : ∀ c : Fin n → Fin 4, + (⨆ k : ℤ, hw.piece (k - ∑ j, lightConeWeight (c j))) = ⊤ := by + intro c + refine le_antisymm le_top ?_ + calc (⊤ : Submodule ℂ W) = ⨆ b, hw.piece b := hw.iSup_piece.symm + _ ≤ ⨆ k : ℤ, hw.piece (k - ∑ j, lightConeWeight (c j)) := + iSup_le fun b => le_iSup_of_le (b + ∑ j, lightConeWeight (c j)) + (by rw [add_sub_cancel_right]) + rw [iSup_comm] + calc (⨆ c : Fin n → Fin 4, ⨆ k : ℤ, + (hw.piece (k - ∑ j, lightConeWeight (c j))).map (lightConeDeriv F i c)) + = ⨆ c : Fin n → Fin 4, LinearMap.range (lightConeDeriv F i c) := by + refine iSup_congr fun c => ?_ + rw [← Submodule.map_iSup, hc c, Submodule.map_top] + _ = ⨆ d : Fin n → Fin 1 ⊕ Fin 3, LinearMap.range (F d) := by + refine le_antisymm (iSup_le fun c => ?_) (iSup_le fun d => ?_) + · rintro _ ⟨w, rfl⟩ + rw [lightConeDeriv, LinearMap.sum_apply] + refine Submodule.sum_mem _ fun d _ => ?_ + rw [LinearMap.smul_apply] + exact Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem d ⟨w, rfl⟩) + · rintro _ ⟨w, rfl⟩ + rw [eq_sum_lightConeDeriv F i d, LinearMap.sum_apply] + refine Submodule.sum_mem _ fun c _ => ?_ + rw [LinearMap.smul_apply] + exact Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem c ⟨w, rfl⟩) + +/-- Each shape of a derivative collection rotates its indices. -/ +lemma rotatesIndices {α : ℕ} + {f : (num : Fin α → ℕ) → (Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) → W →ₗ[ℂ] B} + (hD : IsDerivativeCollection (repLorentz := repLorentz) repW α f) (num : Fin α → ℕ) : + RotatesIndices repW repLorentz (f num) := + fun g d w => hD.repLorentz_equiv g num d w + +/-- **The boost-weight decomposition of the symbols of one shape.** For a term built from + `α` factors carrying `num i` derivatives each, the span of the symbols decomposes into + boost weights along any axis. -/ +noncomputable def boostDecompOfNum {α : ℕ} + {f : (num : Fin α → ℕ) → (Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) → W →ₗ[ℂ] B} + (hD : IsDerivativeCollection (repLorentz := repLorentz) repW α f) (num : Fin α → ℕ) + (i : Fin 3) (hw : WeightDecomposition (K := ℂ) repW i ⊤) : + WeightDecomposition repLorentz i (⨆ d, (f num d).range) := + boostDecomp (f num) (hD.rotatesIndices num) i hw + +/-- **The pieces of `boostDecompOfNum`.** The weight-`k` part is the join, over the + light-cone multi-indices `c`, of the images of the weight-`(k - ∑ lightConeWeight (c j))` + part of `W`: the derivative slots and the argument split the weight between them. -/ +lemma boostDecompOfNum_piece {α : ℕ} + {f : (num : Fin α → ℕ) → (Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) → W →ₗ[ℂ] B} + (hD : IsDerivativeCollection (repLorentz := repLorentz) repW α f) (num : Fin α → ℕ) + (i : Fin 3) (hw : WeightDecomposition (K := ℂ) repW i ⊤) (k : ℤ) : + (hD.boostDecompOfNum num i hw).piece k + = ⨆ c : Fin (∑ i, num i) → Fin 4, + (hw.piece (k - ∑ j, lightConeWeight (c j))).map (lightConeDeriv (f num) i c) := + rfl + +/-- **The pieces when the argument is a Lorentz scalar.** If `W` sits entirely in weight + zero then the weight is carried by the derivative slots alone, and the weight-`k` piece is + spanned by the light-cone symbols whose slots have total weight `k`. -/ +lemma boostDecompOfNum_piece_of_weight_zero {α : ℕ} + {f : (num : Fin α → ℕ) → (Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) → W →ₗ[ℂ] B} + (hD : IsDerivativeCollection (repLorentz := repLorentz) repW α f) (num : Fin α → ℕ) + (i : Fin 3) (hw : WeightDecomposition (K := ℂ) repW i ⊤) (hw0 : hw.piece 0 = ⊤) + (hwb : ∀ b : ℤ, b ≠ 0 → hw.piece b = ⊥) (k : ℤ) : + (hD.boostDecompOfNum num i hw).piece k + = ⨆ (c : Fin (∑ i, num i) → Fin 4) (_ : (∑ j, lightConeWeight (c j)) = k), + LinearMap.range (lightConeDeriv (f num) i c) := by + rw [boostDecompOfNum_piece] + refine iSup_congr fun c => ?_ + by_cases hc : (∑ j, lightConeWeight (c j)) = k + · rw [show k - (∑ j, lightConeWeight (c j)) = 0 from by omega, hw0, Submodule.map_top, + iSup_pos hc] + · rw [hwb _ (by omega), Submodule.map_bot, iSup_neg hc] + +end IsDerivativeCollection + +/-! + +### E.1. The two-factor collection from the Higgs inner product + +The gauge-invariant inner product `dotGaugeHiggs` of a Higgs and a conjugate Higgs, each +carrying its own derivatives, is a two-factor derivative collection over `W = ℂ`: the +Lorentz group rotates the derivative indices of the two factors independently, and the +trivial action on `ℂ` records that the inner product itself is a Lorentz scalar. + +-/ + +/-- The Lorentz action rotates the derivative indices of a Higgs symbol. -/ +lemma repLorentz_higgs {n : ℕ} (g : SL(2,ℂ)) (d : Fin n → Fin 1 ⊕ Fin 3) (k : Fin 2) : + repLorentz g (h.higgs d k) = ∑ a : Fin n → Fin 1 ⊕ Fin 3, + (∏ j, (((SL2C.toLorentzGroup g).1 (a j) (d j) : ℝ) : ℂ)) • h.higgs a k := by + simp only [higgs] + rw [h.repLorentz_H] + +/-- The Lorentz action rotates the derivative indices of a conjugate Higgs symbol. -/ +lemma repLorentz_barHiggs {n : ℕ} (g : SL(2,ℂ)) (d : Fin n → Fin 1 ⊕ Fin 3) (k : Fin 2) : + repLorentz g (h.barHiggs d k) = ∑ a : Fin n → Fin 1 ⊕ Fin 3, + (∏ j, (((SL2C.toLorentzGroup g).1 (a j) (d j) : ℝ) : ℂ)) • h.barHiggs a k := by + simp only [barHiggs] + rw [h.repLorentz_barH] + +/-- **The Higgs inner product as a two-factor symbol map.** The first `num 0` derivative + indices go on the Higgs, the last `num 1` on its conjugate, and the scalar `w : ℂ` scales + the result — the inner product carries no Lorentz index of its own. -/ +noncomputable def dotSymbol (num : Fin 2 → ℕ) + (d : Fin (∑ i, num i) → (Fin 1 ⊕ Fin 3)) : ℂ →ₗ[ℂ] B := + LinearMap.toSpanSingleton ℂ B + (h.dotGaugeHiggs (fun j : Fin (num 0) => d (Fin.castAdd (num 1) j)) + (fun j : Fin (num 1) => d (Fin.natAdd (num 0) j))) + +/-- **The Lorentz action on the Higgs inner product.** The two factors' derivative indices + rotate independently; the inner product itself is a Lorentz scalar. -/ +lemma repLorentz_dotGaugeHiggs {m n : ℕ} (g : SL(2,ℂ)) + (d₁ : Fin m → Fin 1 ⊕ Fin 3) (d₂ : Fin n → Fin 1 ⊕ Fin 3) : + repLorentz g (h.dotGaugeHiggs d₁ d₂) = + ∑ a₁ : Fin m → Fin 1 ⊕ Fin 3, ∑ a₂ : Fin n → Fin 1 ⊕ Fin 3, + ((∏ j, (((SL2C.toLorentzGroup g).1 (a₁ j) (d₁ j) : ℝ) : ℂ)) * + (∏ j, (((SL2C.toLorentzGroup g).1 (a₂ j) (d₂ j) : ℝ) : ℂ))) • + h.dotGaugeHiggs a₁ a₂ := by + simp only [dotGaugeHiggs, map_add, h.repLorentz_mul, repLorentz_higgs, repLorentz_barHiggs, + Finset.sum_mul_sum, smul_mul_smul_comm, smul_add, Finset.sum_add_distrib] + +/-- The weight decomposition of `ℂ` under the trivial Lorentz action: every scalar has + boost weight zero. -/ +noncomputable def trivialWeightDecomposition (i : Fin 3) : + WeightDecomposition (1 : Representation ℂ SL(2,ℂ) ℂ) i ⊤ where + piece k := if k = 0 then ⊤ else ⊥ + supp := {0} + piece_le k := by + by_cases hk : k = 0 + · subst hk + rw [if_pos rfl] + intro x _ t ht + simp + · rw [if_neg hk] + exact bot_le + piece_eq_bot k hk := if_neg (by simpa using hk) + iSup_piece := le_antisymm le_top (le_iSup_of_le 0 (by rw [if_pos rfl])) + +@[simp] +lemma trivialWeightDecomposition_piece (i : Fin 3) (k : ℤ) : + (trivialWeightDecomposition i).piece k = if k = 0 then ⊤ else ⊥ := rfl + +/-- **The Higgs inner product is a two-factor derivative collection.** The Lorentz group + rotates the derivative indices of the two factors independently; the trivial action on + `ℂ` records that the inner product carries no Lorentz index of its own. -/ +lemma isDerivativeCollection_dotSymbol : + IsDerivativeCollection (repLorentz := repLorentz) (1 : Representation ℂ SL(2,ℂ) ℂ) 2 + h.dotSymbol where + repLorentz_equiv g num d w := by + calc repLorentz g (h.dotSymbol num d w) + = ∑ q : (Fin (num 0) → Fin 1 ⊕ Fin 3) × (Fin (num 1) → Fin 1 ⊕ Fin 3), + (w * ((∏ j, (((SL2C.toLorentzGroup g).1 (q.1 j) + (d (Fin.castAdd (num 1) j)) : ℝ) : ℂ)) * + (∏ j, (((SL2C.toLorentzGroup g).1 (q.2 j) + (d (Fin.natAdd (num 0) j)) : ℝ) : ℂ)))) • h.dotGaugeHiggs q.1 q.2 := by + rw [Fintype.sum_prod_type] + simp only [dotSymbol, LinearMap.toSpanSingleton_apply, map_smul, + repLorentz_dotGaugeHiggs, Finset.smul_sum, smul_smul] + _ = ∑ a : Fin (∑ i, num i) → Fin 1 ⊕ Fin 3, + (∏ j, (((SL2C.toLorentzGroup g).1 (a j) (d j) : ℝ) : ℂ)) • + h.dotSymbol num a ((1 : Representation ℂ SL(2,ℂ) ℂ) g w) := by + refine (Fintype.sum_equiv (Fin.appendEquiv (num 0) (num 1)).symm _ _ fun a => ?_).symm + have hprod : ∀ u : Fin (∑ i, num i) → Fin 1 ⊕ Fin 3, + (∏ x, (((SL2C.toLorentzGroup g).1 (u x) (d x) : ℝ) : ℂ)) + = (∏ j : Fin (num 0), (((SL2C.toLorentzGroup g).1 + (u (Fin.castAdd (num 1) j)) (d (Fin.castAdd (num 1) j)) : ℝ) : ℂ)) * + (∏ j : Fin (num 1), (((SL2C.toLorentzGroup g).1 + (u (Fin.natAdd (num 0) j)) (d (Fin.natAdd (num 0) j)) : ℝ) : ℂ)) := + fun u => Fin.prod_univ_add _ + simp only [dotSymbol, LinearMap.toSpanSingleton_apply, MonoidHom.one_apply, + Module.End.one_apply, hprod, Fin.appendEquiv_symm_apply, smul_smul, + mul_comm w, mul_assoc] + rfl + +/-! + +## B. The higgs algebra + +-/ + +/-- The algebra generated by the Higgs, it's conjugate and + all their derivatives. -/ +def higgsAlgebra (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) : + Subalgebra ℂ B := (Algebra.adjoin ℂ (⋃ (k : ℕ) (d : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (H k d) ∪ Set.range (barH k d))) + +/-! + +## B. Mass weight submodules + +-/ + +set_option linter.unusedVariables false in +/-- All terms built from the Higgs symbols and their derivatives which have mass weight + exactly `n`: the intersection of the algebra generated by every `∇_d H` and `∇_d H̄` with + the part on which `massWeightPoly` is the monomial `X ^ n`. -/ +noncomputable def massWeightSubmodule + (h : IsHiggsAlgebraValued B rep repLorentz H barH massWeightPoly) (n : ℕ) : + Submodule ℂ B := + h.higgsAlgebra.toSubmodule + ⊓ LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial n : B →ₗ[B] Polynomial B).restrictScalars ℂ) + +/-- Any two elements of the algebra generated by the Higgs symbols commute. -/ +lemma commute_of_mem_higgsAlgebra {x y : B} (hx : x ∈ h.higgsAlgebra) (hy : y ∈ h.higgsAlgebra) : + Commute x y := by + have hgen : ∀ a ∈ (⋃ (k : ℕ) (d : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (H k d) ∪ Set.range (barH k d)), + ∀ b ∈ (⋃ (k : ℕ) (d : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (H k d) ∪ Set.range (barH k d)), Commute a b := by + intro a ha b hb + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at ha hb + obtain ⟨k1, d1, ⟨φ1, rfl⟩ | ⟨φ1, rfl⟩⟩ := ha <;> + obtain ⟨k2, d2, ⟨φ2, rfl⟩ | ⟨φ2, rfl⟩⟩ := hb + · exact h.H_comm_H _ _ _ _ _ _ + · exact h.H_comm_barH _ _ _ _ _ _ + · exact (h.H_comm_barH _ _ _ _ _ _).symm + · exact h.barH_comm_barH _ _ _ _ _ _ + rw [higgsAlgebra] at hx hy + refine Algebra.commute_of_mem_adjoin_of_forall_mem_commute hy fun b hb => ?_ + exact (Algebra.commute_of_mem_adjoin_of_forall_mem_commute hx fun a ha => hgen b hb a ha).symm + +lemma massWeightPoly_of_mem_massWeightSubmodule {n : ℕ} {x : B} (hx : x ∈ h.massWeightSubmodule n) : + massWeightPoly x = Polynomial.monomial n x := by + rw [massWeightSubmodule, Submodule.mem_inf] at hx + rcases hx with ⟨hx, hx'⟩ + rw [LinearMap.mem_ker] at hx' + simp at hx' + grind + +lemma mem_higgsAlgebra_of_mem_massWeightSubmodule {n : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule n) : x ∈ h.higgsAlgebra := by + rw [massWeightSubmodule, Submodule.mem_inf] at hx + exact hx.1 + +lemma massWeightSubmodule_mul_comm (n m : ℕ) : + h.massWeightSubmodule n * h.massWeightSubmodule m + = h.massWeightSubmodule m * h.massWeightSubmodule n := by + refine le_antisymm (Submodule.mul_le.mpr fun x hx y hy => ?_) + (Submodule.mul_le.mpr fun y hy x hx => ?_) + · rw [(h.commute_of_mem_higgsAlgebra (h.mem_higgsAlgebra_of_mem_massWeightSubmodule hx) + (h.mem_higgsAlgebra_of_mem_massWeightSubmodule hy)).eq] + exact Submodule.mul_mem_mul hy hx + · rw [← (h.commute_of_mem_higgsAlgebra (h.mem_higgsAlgebra_of_mem_massWeightSubmodule hx) + (h.mem_higgsAlgebra_of_mem_massWeightSubmodule hy)).eq] + exact Submodule.mul_mem_mul hx hy + +/-! + +### B.1. Basic grading properties of massWeightPoly + +-/ + +lemma one_le_massWeightSubmodule_zero : (1 : Submodule ℂ B) ≤ h.massWeightSubmodule 0 := by + rw [Submodule.one_eq_span, Submodule.span_le, Set.singleton_subset_iff, SetLike.mem_coe, + massWeightSubmodule, Submodule.mem_inf] + refine ⟨Subalgebra.one_mem _, ?_⟩ + rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero, map_one] + simp + +lemma massWeightSubmodule_mul_le (m n : ℕ) : + h.massWeightSubmodule m * h.massWeightSubmodule n ≤ h.massWeightSubmodule (m + n) := by + rw [Submodule.mul_le] + intro x hx y hy + have hx' := hx + have hy' := hy + rw [massWeightSubmodule, Submodule.mem_inf] at hx hy + rw [massWeightSubmodule, Submodule.mem_inf] + refine ⟨Subalgebra.mul_mem _ hx.1 hy.1, ?_⟩ + rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] + rw [map_mul, h.massWeightPoly_of_mem_massWeightSubmodule hx', + h.massWeightPoly_of_mem_massWeightSubmodule hy', Polynomial.monomial_mul_monomial] + +/-! + +### B.1. The closure of the mass weight submodules under the gauge group + +-/ + +lemma massWeightSubmodule_map_rep_le (n : ℕ) (g : GaugeGroupI) : + (h.massWeightSubmodule n).map (rep g) ≤ h.massWeightSubmodule n := by + have hone : rep g 1 = 1 := by + have h1 := h.rep_mul g 1 (rep g⁻¹ 1) + rw [one_mul, rep.self_inv_apply, mul_one] at h1 + exact h1.symm + let F : B →ₐ[ℂ] B := AlgHom.ofLinearMap (rep g) hone (h.rep_mul g) + have hFapp : ∀ x : B, F x = rep g x := fun _ => rfl + have hFring : ∀ x : B, F.toRingHom x = rep g x := fun _ => rfl + -- the generating symbols are permuted among themselves + have hmaps : ∀ x ∈ (⋃ (k : ℕ) (d : Fin k → (Fin 1 ⊕ Fin 3)), + Set.range (H k d) ∪ Set.range (barH k d)), F x ∈ h.higgsAlgebra := by + intro x hx + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hx + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hx + · refine Algebra.subset_adjoin ?_ + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] + exact ⟨k, d, Or.inl ⟨HiggsVec.repGaugeGroupI.dual g φ, + by rw [hFapp, h.H_equivariant]⟩⟩ + · refine Algebra.subset_adjoin ?_ + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] + exact ⟨k, d, Or.inr ⟨HiggsVec.repGaugeGroupI.conj.dual g φ, + by rw [hFapp, h.barH_equivariant]⟩⟩ + have hadj : h.higgsAlgebra.map F ≤ h.higgsAlgebra := by + rw [higgsAlgebra, AlgHom.map_adjoin] + exact Algebra.adjoin_le (by rintro _ ⟨x, hx, rfl⟩; exact hmaps x hx) + -- the grading is gauge invariant on the generated algebra + have key : ∀ b ∈ h.higgsAlgebra, + massWeightPoly (F b) = (massWeightPoly b).map F.toRingHom := by + intro b hb + rw [higgsAlgebra] at hb + induction hb using Algebra.adjoin_induction with + | mem x hx => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hx + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hx + · rw [hFapp, h.H_equivariant, h.H_massWeight, h.H_massWeight, + Polynomial.map_monomial, hFring, h.H_equivariant] + · rw [hFapp, h.barH_equivariant, h.barH_massWeight, h.barH_massWeight, + Polynomial.map_monomial, hFring, h.barH_equivariant] + | algebraMap r => simp + | add x y hx hy ihx ihy => rw [map_add, map_add, map_add, Polynomial.map_add, ihx, ihy] + | mul x y hx hy ihx ihy => rw [map_mul, map_mul, map_mul, Polynomial.map_mul, ihx, ihy] + rintro _ ⟨b, hb, rfl⟩ + rw [SetLike.mem_coe] at hb + have hb' := hb + rw [massWeightSubmodule, Submodule.mem_inf] at hb + rw [massWeightSubmodule, Submodule.mem_inf] + refine ⟨hadj ⟨b, hb.1, rfl⟩, ?_⟩ + rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] + rw [← hFapp, key b hb.1, h.massWeightPoly_of_mem_massWeightSubmodule hb', + Polynomial.map_monomial, hFring, hFapp] + +lemma massWeightSubmodule_closure (n : ℕ) (g : GaugeGroupI) : + (h.massWeightSubmodule n).map (rep g) = h.massWeightSubmodule n := + le_antisymm (h.massWeightSubmodule_map_rep_le n g) fun b hb => + ⟨rep g⁻¹ b, h.massWeightSubmodule_map_rep_le n g⁻¹ ⟨b, hb, rfl⟩, + rep.self_inv_apply g b⟩ + +/-! + +### B.2. The odd mass weight submodules + +Every term in the Higgs algebra has even mass weight, so the odd mass weight submodules are +trivial. +-/ + +lemma massWeightSubmodule_odd_eq_bot (n : ℕ) (hn : Odd n) : + h.massWeightSubmodule n = ⊥ := by + refine le_antisymm (fun b hb => ?_) bot_le + have hb' := hb + rw [massWeightSubmodule, Submodule.mem_inf] at hb + -- every generator has even mass weight, and weights add under multiplication + have key : ∀ x ∈ h.higgsAlgebra, ∀ i, Odd i → (massWeightPoly x).coeff i = 0 := by + intro x hx + rw [higgsAlgebra] at hx + induction hx using Algebra.adjoin_induction with + | mem y hy => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hy + · intro i hi + rw [h.H_massWeight, Polynomial.coeff_monomial, if_neg] + rintro rfl + obtain ⟨r, hr⟩ := hi + omega + · intro i hi + rw [h.barH_massWeight, Polynomial.coeff_monomial, if_neg] + rintro rfl + obtain ⟨r, hr⟩ := hi + omega + | algebraMap r => + intro i hi + have hi0 : i ≠ 0 := by rintro rfl; simp at hi + rw [AlgHom.commutes] + simp [Polynomial.algebraMap_apply, Polynomial.coeff_C, hi0] + | add x y hx hy ihx ihy => + intro i hi + rw [map_add, Polynomial.coeff_add, ihx i hi, ihy i hi, add_zero] + | mul x y hx hy ihx ihy => + intro i hi + rw [map_mul, Polynomial.coeff_mul] + refine Finset.sum_eq_zero fun p hp => ?_ + have hsum := Finset.mem_antidiagonal.mp hp + rcases Nat.even_or_odd p.1 with ⟨a, ha⟩ | ho + · obtain ⟨c, hc⟩ := hi + rw [ihy p.2 ⟨c - a, by omega⟩, mul_zero] + · rw [ihx p.1 ho, zero_mul] + have hcoeff := key b hb.1 n hn + rw [h.massWeightPoly_of_mem_massWeightSubmodule hb', Polynomial.coeff_monomial, + if_pos rfl] at hcoeff + exact hcoeff + +/-! + +### B.3. The inclusion of the Higgs and conjugate Higgs submodules in the mass weight submodule + +-/ + +lemma massWeightSubmodule_higgsSubmodule_le (n : ℕ) : + h.higgsSubmodule n ≤ h.massWeightSubmodule (2 * (1 + n)) := by + rw [higgsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + rw [massWeightSubmodule, Submodule.mem_inf] + refine ⟨Algebra.subset_adjoin ?_, ?_⟩ + · simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] + exact ⟨n, d, Or.inl ⟨φ, rfl⟩⟩ + · rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] + rw [h.H_massWeight] + +lemma massWeightSubmodule_barHiggsSubmodule_le (n : ℕ) : + h.barHiggsSubmodule n ≤ h.massWeightSubmodule (2 * (1 + n)) := by + rw [barHiggsSubmodule] + refine iSup_le fun d => ?_ + rintro _ ⟨φ, rfl⟩ + rw [massWeightSubmodule, Submodule.mem_inf] + refine ⟨Algebra.subset_adjoin ?_, ?_⟩ + · simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] + exact ⟨n, d, Or.inr ⟨φ, rfl⟩⟩ + · rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] + rw [h.barH_massWeight] + +/-! + +### B.4. Decomposition of the mass weight submodule + +-/ + +lemma massWeightSubmodule_eq (i : ℕ) (hi : 0 < i) : + h.massWeightSubmodule i + = (⨆ k ∈ Finset.univ.filter (fun k : Fin i => 2 * (1 + (k : ℕ)) = i), + h.higgsSubmodule (k : ℕ) ⊔ h.barHiggsSubmodule (k : ℕ)) + ⊔ (⨆ p ∈ Finset.univ.filter (fun p : Fin i × Fin i => (p.1 : ℕ) + (p.2 : ℕ) = i), + h.massWeightSubmodule (p.1 : ℕ) * h.massWeightSubmodule (p.2 : ℕ)) := by + refine le_antisymm (fun b hb => ?_) (sup_le ?_ ?_) + · -- the weight-zero component of an element of the algebra is a scalar + have hzero : ∀ x ∈ h.higgsAlgebra, (massWeightPoly x).coeff 0 ∈ (1 : Submodule ℂ B) := by + intro x hx + rw [higgsAlgebra] at hx + induction hx using Algebra.adjoin_induction with + | mem y hy => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hy + · rw [h.H_massWeight, Polynomial.coeff_monomial, if_neg (by omega)] + exact zero_mem _ + · rw [h.barH_massWeight, Polynomial.coeff_monomial, if_neg (by omega)] + exact zero_mem _ + | algebraMap r => + rw [AlgHom.commutes] + simp only [Polynomial.algebraMap_apply, Polynomial.coeff_C] + exact Submodule.mem_one.mpr ⟨r, rfl⟩ + | add x y hx hy ihx ihy => + rw [map_add, Polynomial.coeff_add] + exact Submodule.add_mem _ ihx ihy + | mul x y hx hy ihx ihy => + rw [map_mul, Polynomial.mul_coeff_zero] + have hmem := Submodule.mul_mem_mul ihx ihy + rwa [Submodule.one_mul] at hmem + -- the components of an element of the algebra are homogeneous + have hcomp : ∀ x ∈ h.higgsAlgebra, ∀ m, (massWeightPoly x).coeff m + ∈ h.massWeightSubmodule m := by + intro x hx + rw [higgsAlgebra] at hx + induction hx using Algebra.adjoin_induction with + | mem y hy => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hy + · intro m + rw [h.H_massWeight, Polynomial.coeff_monomial] + split_ifs with hw + · subst hw + exact h.massWeightSubmodule_higgsSubmodule_le k + (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩) + · exact zero_mem _ + · intro m + rw [h.barH_massWeight, Polynomial.coeff_monomial] + split_ifs with hw + · subst hw + exact h.massWeightSubmodule_barHiggsSubmodule_le k + (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩) + · exact zero_mem _ + | algebraMap r => + intro m + rw [AlgHom.commutes] + simp only [Polynomial.algebraMap_apply, Polynomial.coeff_C] + split_ifs with hm + · subst hm + exact h.one_le_massWeightSubmodule_zero (Submodule.mem_one.mpr ⟨r, rfl⟩) + · exact zero_mem _ + | add x y hx hy ihx ihy => + intro m + rw [map_add, Polynomial.coeff_add] + exact Submodule.add_mem _ (ihx m) (ihy m) + | mul x y hx hy ihx ihy => + intro m + rw [map_mul, Polynomial.coeff_mul] + refine Submodule.sum_mem _ fun p hp => ?_ + have hsum := Finset.mem_antidiagonal.mp hp + subst hsum + exact h.massWeightSubmodule_mul_le _ _ (Submodule.mul_mem_mul (ihx p.1) (ihy p.2)) + -- the weight-`m` component lands in the right-hand side, for every positive `m` + have main : ∀ x ∈ h.higgsAlgebra, ∀ m, 0 < m → (massWeightPoly x).coeff m + ∈ (⨆ k ∈ Finset.univ.filter (fun k : Fin m => 2 * (1 + (k : ℕ)) = m), + h.higgsSubmodule (k : ℕ) ⊔ h.barHiggsSubmodule (k : ℕ)) + ⊔ (⨆ p ∈ Finset.univ.filter (fun p : Fin m × Fin m => (p.1 : ℕ) + (p.2 : ℕ) = m), + h.massWeightSubmodule (p.1 : ℕ) * h.massWeightSubmodule (p.2 : ℕ)) := by + intro x hx + rw [higgsAlgebra] at hx + induction hx using Algebra.adjoin_induction with + | mem y hy => + simp only [Set.mem_iUnion, Set.mem_union, Set.mem_range] at hy + obtain ⟨k, d, (⟨φ, rfl⟩ | ⟨φ, rfl⟩)⟩ := hy + · intro m _ + rw [h.H_massWeight, Polynomial.coeff_monomial] + split_ifs with hw + · exact Submodule.mem_sup_left (Submodule.mem_iSup_of_mem ⟨k, by omega⟩ + (Submodule.mem_iSup_of_mem (Finset.mem_filter.mpr ⟨Finset.mem_univ _, hw⟩) + (Submodule.mem_sup_left (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩)))) + · exact zero_mem _ + · intro m _ + rw [h.barH_massWeight, Polynomial.coeff_monomial] + split_ifs with hw + · exact Submodule.mem_sup_left (Submodule.mem_iSup_of_mem ⟨k, by omega⟩ + (Submodule.mem_iSup_of_mem (Finset.mem_filter.mpr ⟨Finset.mem_univ _, hw⟩) + (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem d ⟨φ, rfl⟩)))) + · exact zero_mem _ + | algebraMap r => + intro m hm + rw [AlgHom.commutes] + simp only [Polynomial.algebraMap_apply, Polynomial.coeff_C, if_neg (by omega : ¬ m = 0)] + exact zero_mem _ + | add x y hx hy ihx ihy => + intro m hm + rw [map_add, Polynomial.coeff_add] + exact Submodule.add_mem _ (ihx m hm) (ihy m hm) + | mul x y hx hy ihx ihy => + intro m hm + rw [map_mul, Polynomial.coeff_mul] + refine Submodule.sum_mem _ fun p hp => ?_ + obtain ⟨j, l⟩ := p + have hsum := Finset.mem_antidiagonal.mp hp + simp only at hsum ⊢ + rcases Nat.eq_zero_or_pos j with rfl | hj + · have hlm : l = m := by omega + rw [hlm] + have hmem := Submodule.mul_mem_mul (hzero x hx) (ihy m hm) + rwa [Submodule.one_mul] at hmem + · rcases Nat.eq_zero_or_pos l with rfl | hl + · have hjm : j = m := by omega + rw [hjm] + have hmem := Submodule.mul_mem_mul (ihx m hm) (hzero y hy) + rwa [Submodule.mul_one] at hmem + · refine Submodule.mem_sup_right (Submodule.mem_iSup_of_mem + ((⟨⟨j, by omega⟩, ⟨l, by omega⟩⟩ : Fin m × Fin m)) + (Submodule.mem_iSup_of_mem (Finset.mem_filter.mpr ⟨Finset.mem_univ _, hsum⟩) ?_)) + exact Submodule.mul_mem_mul (hcomp x hx j) (hcomp y hy l) + have hb' := hb + rw [massWeightSubmodule, Submodule.mem_inf] at hb + have hmain := main b hb.1 i hi + rwa [h.massWeightPoly_of_mem_massWeightSubmodule hb', Polynomial.coeff_monomial, + if_pos rfl] at hmain + · refine iSup_le fun k => iSup_le fun hk => ?_ + have hk' := (Finset.mem_filter.mp hk).2 + exact (sup_le (h.massWeightSubmodule_higgsSubmodule_le (k : ℕ)) + (h.massWeightSubmodule_barHiggsSubmodule_le (k : ℕ))).trans (le_of_eq (by rw [hk'])) + · refine iSup_le fun p => iSup_le fun hp => ?_ + have hp' := (Finset.mem_filter.mp hp).2 + exact (h.massWeightSubmodule_mul_le (p.1 : ℕ) (p.2 : ℕ)).trans (le_of_eq (by rw [hp'])) + +/-- **The gauge weight decomposition of the mass weight submodules.** By recursion on the + weight through `massWeightSubmodule_eq`: a term of weight `i` is either a symbol of that + weight — decomposed by `higgsSubmoduleGaugeWeight` and `barHiggsSubmoduleGaugeWeight` — or a + product of two terms of lower positive weight, decomposed by `mul` from the decompositions + supplied by the recursion. -/ +@[implicit_reducible] +noncomputable def massWeightSubmoduleGaugeWeight : + (i : ℕ) → 0 < i → GaugeWeightDecomposition rep (h.massWeightSubmodule i) := by + intro i + induction i using Nat.strongRecOn with + | _ i ih => + intro hi + refine (GaugeWeightDecomposition.sup (d := ?_) (d' := ?_)).copy _ + (h.massWeightSubmodule_eq i hi) + · exact GaugeWeightDecomposition.iSup h.rep_mul fun k : Fin i => + GaugeWeightDecomposition.iSupProp h.rep_mul fun _ => + GaugeWeightDecomposition.sup (d := h.higgsSubmoduleGaugeWeight (k : ℕ)) + (d' := h.barHiggsSubmoduleGaugeWeight (k : ℕ)) + · exact GaugeWeightDecomposition.iSup h.rep_mul fun p : Fin i × Fin i => + GaugeWeightDecomposition.iSupProp h.rep_mul fun hp => + have hsum : (p.1 : ℕ) + (p.2 : ℕ) = i := (Finset.mem_filter.mp hp).2 + have hj : (p.1 : ℕ) < i := p.1.isLt + have hl : (p.2 : ℕ) < i := p.2.isLt + GaugeWeightDecomposition.mul (d := ih (p.1 : ℕ) hj (by omega)) + (d' := ih (p.2 : ℕ) hl (by omega)) + +/-- The `NeZero` form of `massWeightSubmoduleGaugeWeight`. -/ +noncomputable instance massWeightSubmoduleGaugeWeightOfNeZero (i : ℕ) [NeZero i] : + GaugeWeightDecomposition rep (h.massWeightSubmodule i) := + h.massWeightSubmoduleGaugeWeight i (Nat.pos_of_ne_zero (NeZero.ne i)) + +/-! + +### B.6. Expansion of the low dimensional cases + +-/ + +open GaugeWeightDecomposition + +lemma massWeightSubmodule_two_eq : + h.massWeightSubmodule 2 = h.higgsSubmodule 0 ⊔ h.barHiggsSubmodule 0 := by + rw [h.massWeightSubmodule_eq 2 (by decide)] + rw [show (Finset.univ.filter (fun k : Fin 2 => 2 * (1 + (k : ℕ)) = 2)) = {0} from by decide, + show (Finset.univ.filter (fun p : Fin 2 × Fin 2 => (p.1 : ℕ) + (p.2 : ℕ) = 2)) = {(1, 1)} + from by decide] + simp only [Fin.isValue, Finset.mem_singleton, iSup_iSup_eq_left, Fin.coe_ofNat_eq_mod, + Nat.zero_mod, Nat.mod_succ, h.massWeightSubmodule_odd_eq_bot 1 (by decide), Submodule.mul_bot, + bot_le, sup_of_le_left] + +lemma massWeightSubmodule_four_eq : + h.massWeightSubmodule 4 = h.higgsSubmodule 1 ⊔ h.barHiggsSubmodule 1 ⊔ + h.higgsSubmodule 0 * h.higgsSubmodule 0 ⊔ h.higgsSubmodule 0 * + h.barHiggsSubmodule 0 ⊔ h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0:= by + rw [h.massWeightSubmodule_eq 4 (by decide)] + rw [show (Finset.univ.filter (fun k : Fin 4 => 2 * (1 + (k : ℕ)) = 4)) = {1} from by decide, + show (Finset.univ.filter (fun p : Fin 4 × Fin 4 => (p.1 : ℕ) + (p.2 : ℕ) = 4)) = + {(1, 3), (3, 1), (2, 2)} from by decide] + simp [Fin.isValue, Finset.mem_singleton, iSup_iSup_eq_left, Fin.coe_ofNat_eq_mod, + Nat.one_mod,- Finset.mem_insert, Finset.iSup_insert, + h.massWeightSubmodule_odd_eq_bot 1 (by decide), + massWeightSubmodule_two_eq, ] + simp [Submodule.sup_mul, Submodule.mul_sup, Submodule.mul_sup, + barHiggsSubmodule_comm_higgsSubmodule, ← sup_assoc] + +lemma massWeightSubmodule_six_eq : h.massWeightSubmodule 6 = + -- The derivative terms + h.higgsSubmodule 2 ⊔ h.barHiggsSubmodule 2 ⊔ + h.higgsSubmodule 1 * h.higgsSubmodule 0 ⊔ + h.higgsSubmodule 1 * h.barHiggsSubmodule 0 ⊔ + h.barHiggsSubmodule 1 * h.higgsSubmodule 0 ⊔ + h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0 ⊔ + -- The potential terms + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.higgsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 := by + rw [h.massWeightSubmodule_eq 6 (by decide)] + rw [show (Finset.univ.filter (fun k : Fin 6 => 2 * (1 + (k : ℕ)) = 6)) = {2} from by decide, + show (Finset.univ.filter (fun p : Fin 6 × Fin 6 => (p.1 : ℕ) + (p.2 : ℕ) = 6)) = + {(1, 5), (5, 1), (2, 4), (4, 2), (3, 3)} from by decide] + simp (disch := decide) [Fin.isValue, Finset.mem_singleton, iSup_iSup_eq_left, Fin.coe_ofNat_eq_mod, + Nat.one_mod,- Finset.mem_insert, Finset.iSup_insert, + h.massWeightSubmodule_odd_eq_bot, h.massWeightSubmodule_mul_comm, + bot_sup_eq, sup_bot_eq, sup_idem] + rw [massWeightSubmodule_two_eq, massWeightSubmodule_four_eq] + have hlc : ∀ (n1 n2 : ℕ) (C : Submodule ℂ B), + h.barHiggsSubmodule n1 * (h.higgsSubmodule n2 * C) + = h.higgsSubmodule n2 * (h.barHiggsSubmodule n1 * C) := + fun n1 n2 C => Commute.left_comm (h.barHiggsSubmodule_comm_higgsSubmodule n1 n2) C + simp only [Submodule.sup_mul, Submodule.mul_sup, barHiggsSubmodule_comm_higgsSubmodule, + mul_assoc, hlc, h.higgsSubmodule_comm_higgsSubmodule 0 1 (by decide), + h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1 (by decide), ← sup_assoc, sup_right_idem] + +lemma massWeightSubmodule_eight_eq : + h.massWeightSubmodule 8 = + -- The derivative terms + h.higgsSubmodule 3 ⊔ h.barHiggsSubmodule 3 ⊔ + h.higgsSubmodule 2 * h.higgsSubmodule 0 ⊔ + h.higgsSubmodule 2 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.barHiggsSubmodule 2 ⊔ + h.barHiggsSubmodule 2 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 1 * h.higgsSubmodule 1 ⊔ + h.higgsSubmodule 1 * h.barHiggsSubmodule 1 ⊔ + h.barHiggsSubmodule 1 * h.barHiggsSubmodule 1 ⊔ + h.higgsSubmodule 1 * h.higgsSubmodule 0 * h.higgsSubmodule 0 ⊔ + h.higgsSubmodule 1 * h.higgsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 1 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.barHiggsSubmodule 1 ⊔ + h.higgsSubmodule 0 * h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0 ⊔ + h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + -- The potential terms + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.higgsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.higgsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.higgsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 ⊔ + h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0 * + h.barHiggsSubmodule 0 := by + rw [h.massWeightSubmodule_eq 8 (by decide)] + rw [show (Finset.univ.filter (fun k : Fin 8 => 2 * (1 + (k : ℕ)) = 8)) = {3} from by decide, + show (Finset.univ.filter (fun p : Fin 8 × Fin 8 => (p.1 : ℕ) + (p.2 : ℕ) = 8)) = + {(1, 7), (7, 1), (2, 6), (6, 2), (3, 5), (5, 3), (4, 4)} from by decide] + simp (disch := decide) [Fin.isValue, Finset.mem_singleton, iSup_iSup_eq_left, Fin.coe_ofNat_eq_mod, + Nat.one_mod,- Finset.mem_insert, Finset.iSup_insert, + h.massWeightSubmodule_odd_eq_bot, h.massWeightSubmodule_mul_comm, + bot_sup_eq, sup_left_idem] + rw [massWeightSubmodule_two_eq, massWeightSubmodule_four_eq, massWeightSubmodule_six_eq] + have hlc : ∀ (n1 n2 : ℕ) (C : Submodule ℂ B), + h.barHiggsSubmodule n1 * (h.higgsSubmodule n2 * C) + = h.higgsSubmodule n2 * (h.barHiggsSubmodule n1 * C) := + fun n1 n2 C => Commute.left_comm (h.barHiggsSubmodule_comm_higgsSubmodule n1 n2) C + have hlcH : ∀ (C : Submodule ℂ B), + h.higgsSubmodule 0 * (h.higgsSubmodule 1 * C) + = h.higgsSubmodule 1 * (h.higgsSubmodule 0 * C) := + fun C => Commute.left_comm (h.higgsSubmodule_comm_higgsSubmodule 0 1 (by decide)) C + have hlcB : ∀ (C : Submodule ℂ B), + h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 1 * C) + = h.barHiggsSubmodule 1 * (h.barHiggsSubmodule 0 * C) := + fun C => Commute.left_comm (h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1 (by decide)) C + simp only [Submodule.sup_mul, Submodule.mul_sup, barHiggsSubmodule_comm_higgsSubmodule, + mul_assoc, hlc, hlcH, hlcB, + h.higgsSubmodule_comm_higgsSubmodule 0 1 (by decide), + h.higgsSubmodule_comm_higgsSubmodule 0 2 (by decide), + h.barHiggsSubmodule_comm_barHiggsSubmodule 0 1 (by decide), + h.barHiggsSubmodule_comm_barHiggsSubmodule 0 2 (by decide)] + generalize h.higgsSubmodule 3 = v1 + generalize h.barHiggsSubmodule 3 = v2 + generalize h.higgsSubmodule 2 * h.higgsSubmodule 0 = v3 + generalize h.higgsSubmodule 2 * h.barHiggsSubmodule 0 = v4 + generalize h.higgsSubmodule 0 * h.barHiggsSubmodule 2 = v5 + generalize h.barHiggsSubmodule 2 * h.barHiggsSubmodule 0 = v6 + generalize h.higgsSubmodule 1 * h.higgsSubmodule 1 = v7 + generalize h.higgsSubmodule 1 * h.barHiggsSubmodule 1 = v8 + generalize h.barHiggsSubmodule 1 * h.barHiggsSubmodule 1 = v9 + generalize h.higgsSubmodule 1 * (h.higgsSubmodule 0 * h.higgsSubmodule 0) = v10 + generalize h.higgsSubmodule 1 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 0) = v11 + generalize h.higgsSubmodule 1 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v12 + generalize h.higgsSubmodule 0 * (h.higgsSubmodule 0 * h.barHiggsSubmodule 1) = v13 + generalize h.higgsSubmodule 0 * (h.barHiggsSubmodule 1 * h.barHiggsSubmodule 0) = v14 + generalize h.barHiggsSubmodule 1 * (h.barHiggsSubmodule 0 * h.barHiggsSubmodule 0) = v15 + generalize h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.higgsSubmodule 0 * + h.higgsSubmodule 0)) = v16 + generalize h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.higgsSubmodule 0 * + h.barHiggsSubmodule 0)) = v17 + generalize h.higgsSubmodule 0 * (h.higgsSubmodule 0 * (h.barHiggsSubmodule 0 * + h.barHiggsSubmodule 0)) = v18 + generalize h.higgsSubmodule 0 * (h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * + h.barHiggsSubmodule 0)) = v19 + generalize h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * (h.barHiggsSubmodule 0 * + h.barHiggsSubmodule 0)) = v20 + simp only [sup_comm, sup_left_comm, sup_idem, sup_left_idem] + +/-! + +## C. Gauge invariance + +We now turn to the gauge invariance of the +different terms. + +-/ + +/-! + +### C.1. The weigh-zero pieces of the low-dimensional mass weight + +-/ + +lemma massWeightSubmodule_two_peice_zero : + piece rep (h.massWeightSubmodule 2) 0 = ⊥ := by + simp (disch := decide) [piece_congr h.massWeightSubmodule_two_eq, if_neg] + + +lemma massWeightSubmodule_four_peice_zero : + piece rep (h.massWeightSubmodule 4) 0 = Submodule.span ℂ + {h.higgs ![] 0 * h.barHiggs ![] 0, h.higgs ![] 1 * h.barHiggs ![] 1} := by + simp (disch := decide) [if_neg, piece_congr h.massWeightSubmodule_four_eq] + simp only [Std.le_refl, sup_of_le_left, mul_piece_eq_sub, supp, Int.reduceNeg, + higgsSubmoduleGaugeWeight_piece, Fin.isValue, ciSup_unique, barHiggsSubmoduleGaugeWeight_piece, + zero_sub, Finset.iSup_insert, Prod.mk.injEq, reduceCtorEq, and_self, and_false, ↓reduceIte, + bot_le, sup_of_le_right, Prod.neg_mk, neg_zero, neg_neg, and_true, Finset.mem_singleton, + iSup_iSup_eq_left, Matrix.empty_eq, Submodule.span_mul_span, Set.singleton_mul_singleton, + Submodule.span_insert] + simp + +lemma massWeightSubmodule_six_peice_zero : + piece rep (h.massWeightSubmodule 6) 0 = + (⨆ (d : Fin 1 → _), ℂ ∙ h.higgs d 0 * h.barHiggs ![] 0) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ h.higgs d 1 * h.barHiggs ![] 1) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ h.barHiggs d 0 * h.higgs ![] 0) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ h.barHiggs d 1 * h.higgs ![] 1) := by + simp (disch := decide) [if_neg, piece_congr h.massWeightSubmodule_six_eq] + simp only [mul_piece_eq_sub', supp, Finset.iSup_insert, Finset.iSup_singleton] + simp (disch := decide) [if_neg, sup_bot_eq, bot_sup_eq] + simp only [Matrix.empty_eq, Submodule.iSup_mul, Submodule.span_mul_span, + Set.singleton_mul_singleton, sup_assoc] + +lemma massWeightSubmodule_eight_peice_zero : + piece rep (h.massWeightSubmodule 8) 0 = + (⨆ (d : Fin 2 → _), ℂ ∙ h.higgs d 0 * h.barHiggs ![] 0) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.higgs d 1 * h.barHiggs ![] 1) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.barHiggs d 0 * h.higgs ![] 0) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.barHiggs d 1 * h.higgs ![] 1) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ h.higgs d 0 * h.barHiggs d2 0) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ h.higgs d 1 * h.barHiggs d2 1) ⊔ + ℂ ∙ h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 ⊔ + ℂ ∙ h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1 ⊔ + ℂ ∙ h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 := by + simp (disch := decide) [if_neg, piece_congr h.massWeightSubmodule_eight_eq] + simp only [mul_piece_eq_sub', supp, Finset.iSup_insert, Finset.iSup_singleton] + simp (disch := decide) [if_neg, sup_bot_eq, bot_sup_eq] + have hbh2 : ∀ (n1 n2 : ℕ) (d1 : Fin n1 → Fin 1 ⊕ Fin 3) (d2 : Fin n2 → Fin 1 ⊕ Fin 3) + (a b : Fin 2), h.barHiggs d1 a * h.higgs d2 b = h.higgs d2 b * h.barHiggs d1 a := + fun n1 n2 d1 d2 a b => ((h.H_comm_barH _ _ _ _ _ _).symm).eq + have hhh2 : h.higgs ![] 1 * h.higgs ![] 0 = h.higgs ![] 0 * h.higgs ![] 1 := + (h.H_comm_H _ _ _ _ _ _).eq + have hbb2 : h.barHiggs ![] 1 * h.barHiggs ![] 0 = h.barHiggs ![] 0 * h.barHiggs ![] 1 := + (h.barH_comm_barH _ _ _ _ _ _).eq + simp only [Matrix.empty_eq, Submodule.sup_mul, Submodule.iSup_mul, + Submodule.mul_iSup, Submodule.span_mul_span, Set.singleton_mul_singleton, + mul_assoc, hbh2, hhh2, hbb2, ← sup_assoc, sup_idem, sup_right_idem] + have hswap : ∀ a : Fin 2, (⨆ i : Fin 1 → Fin 1 ⊕ Fin 3, ⨆ j : Fin 1 → Fin 1 ⊕ Fin 3, + ℂ ∙ h.higgs j a * h.barHiggs i a) + = ⨆ j : Fin 1 → Fin 1 ⊕ Fin 3, ⨆ i : Fin 1 → Fin 1 ⊕ Fin 3, + ℂ ∙ h.higgs j a * h.barHiggs i a := fun a => iSup_comm + rw [hswap 0, hswap 1] + +/-! + +### C.2. The instances of the SU2 Perm decompositions + +-/ + +noncomputable def massWeightFourPermDecomposition : + SU2PermDecomposition rep (piece rep (h.massWeightSubmodule 4) 0) where + piece := fun w => + if w = 0 then ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 + h.higgs ![] 1 * h.barHiggs ![] 1) + else if w = 2 then ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + else ⊥ + piece_le := by + intro k x hx + rcases eq_or_ne k 0 with rfl | hk0 + · rw [if_pos rfl, Submodule.mem_span_singleton] at hx + obtain ⟨c, rfl⟩ := hx + rw [map_smul, h.rep_gaugeSU2Perm_higgsBarHiggs_add, su2PermSign_zero, one_smul] + · rcases eq_or_ne k 2 with rfl | hk2 + · rw [if_neg hk0, if_pos rfl, Submodule.mem_span_singleton] at hx + obtain ⟨c, rfl⟩ := hx + rw [map_smul, h.rep_gaugeSU2Perm_higgsBarHiggs_sub, su2PermSign_two, smul_neg, + neg_smul, one_smul] + · rw [if_neg hk0, if_neg hk2, Submodule.mem_bot] at hx + subst hx + simp + iSup_piece := by + rw [h.massWeightSubmodule_four_peice_zero] + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + refine le_antisymm (iSup_le fun k => ?_) ?_ + · rcases hcases k with rfl | rfl | rfl | rfl + · rw [if_pos rfl, Submodule.span_le, Set.singleton_subset_iff] + exact Submodule.add_mem _ (Submodule.subset_span (by simp)) + (Submodule.subset_span (by simp)) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · rw [if_neg (by decide), if_pos rfl, Submodule.span_le, Set.singleton_subset_iff] + exact Submodule.sub_mem _ (Submodule.subset_span (by simp)) + (Submodule.subset_span (by simp)) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · refine le_trans ?_ (sup_le (le_iSup _ (0 : ZMod 4)) (le_iSup _ (2 : ZMod 4))) + rw [if_pos rfl, if_neg (by decide : ¬(2 : ZMod 4) = 0), if_pos rfl, Submodule.span_le] + have hp := Submodule.mem_sup_left + (S := ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 + h.higgs ![] 1 * h.barHiggs ![] 1)) + (T := ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + (Submodule.mem_span_singleton_self _) + have hm := Submodule.mem_sup_right + (S := ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 + h.higgs ![] 1 * h.barHiggs ![] 1)) + (T := ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + (Submodule.mem_span_singleton_self _) + rintro x (rfl | rfl) + · have hs := Submodule.smul_mem _ (2⁻¹ : ℂ) (Submodule.add_mem _ hp hm) + rwa [show (2⁻¹ : ℂ) • ((h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1) + + (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + = h.higgs ![] 0 * h.barHiggs ![] 0 from by module] at hs + · have hs := Submodule.smul_mem _ (2⁻¹ : ℂ) (Submodule.sub_mem _ hp hm) + rwa [show (2⁻¹ : ℂ) • ((h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1) + - (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + = h.higgs ![] 1 * h.barHiggs ![] 1 from by module] at hs + + +noncomputable def massWeightSixPermDecomposition : + SU2PermDecomposition rep (piece rep (h.massWeightSubmodule 6) 0) where + piece := fun w => + if w = 0 then + (⨆ (d : Fin 1 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs ![] 0 + + h.higgs d 1 * h.barHiggs ![] 1)) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ (h.higgs ![] 0 * h.barHiggs d 0 + + h.higgs ![] 1 * h.barHiggs d 1)) + else if w = 2 then + (⨆ (d : Fin 1 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs ![] 0 + - h.higgs d 1 * h.barHiggs ![] 1)) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ (h.higgs ![] 0 * h.barHiggs d 0 + - h.higgs ![] 1 * h.barHiggs d 1)) + else ⊥ + piece_le := by + have key : ∀ (s : ℂ) (S : Submodule ℂ B), S ≤ Module.End.eigenspace (rep gaugeSU2Perm) s → + ∀ x ∈ S, rep gaugeSU2Perm x = s • x := + fun s S hS x hx => Module.End.mem_eigenspace_iff.mp (hS hx) + intro k x hx + rcases eq_or_ne k 0 with rfl | hk0 + · rw [if_pos rfl] at hx + refine key _ _ ?_ x hx + refine sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] <;> + exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_add, su2PermSign_zero, one_smul]) + · rcases eq_or_ne k 2 with rfl | hk2 + · rw [if_neg hk0, if_pos rfl] at hx + refine key _ _ ?_ x hx + refine sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] <;> + exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_sub, su2PermSign_two, neg_one_smul]) + · rw [if_neg hk0, if_neg hk2, Submodule.mem_bot] at hx + subst hx + simp + iSup_piece := by + have hcomm : ∀ {n1 n2 : ℕ} (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) + (a b : Fin 2), h.barHiggs d1 a * h.higgs d2 b = h.higgs d2 b * h.barHiggs d1 a := + fun d1 d2 a b => ((h.H_comm_barH _ _ _ _ _ _).symm).eq + rw [h.massWeightSubmodule_six_peice_zero] + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + refine le_antisymm (iSup_le fun k => ?_) ?_ + · rcases hcases k with rfl | rfl | rfl | rfl + · rw [if_pos rfl] + refine sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [← hcomm d ![] 0 0, ← hcomm d ![] 1 1] + exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · rw [if_neg (by decide), if_pos rfl] + refine sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [← hcomm d ![] 0 0, ← hcomm d ![] 1 1] + exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · refine le_trans ?_ (sup_le (le_iSup _ (0 : ZMod 4)) (le_iSup _ (2 : ZMod 4))) + rw [if_pos rfl, if_neg (by decide : ¬(2 : ZMod 4) = 0), if_pos rfl] + refine sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => ?_)) (iSup_le fun d => ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · rw [show h.higgs d 0 * h.barHiggs ![] 0 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs ![] 0 + h.higgs d 1 * h.barHiggs ![] 1) + + (h.higgs d 0 * h.barHiggs ![] 0 - h.higgs d 1 * h.barHiggs ![] 1)) + from by module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [show h.higgs d 1 * h.barHiggs ![] 1 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs ![] 0 + h.higgs d 1 * h.barHiggs ![] 1) + - (h.higgs d 0 * h.barHiggs ![] 0 - h.higgs d 1 * h.barHiggs ![] 1)) + from by module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [hcomm d ![] 0 0, show h.higgs ![] 0 * h.barHiggs d 0 = (2⁻¹ : ℂ) • + ((h.higgs ![] 0 * h.barHiggs d 0 + h.higgs ![] 1 * h.barHiggs d 1) + + (h.higgs ![] 0 * h.barHiggs d 0 - h.higgs ![] 1 * h.barHiggs d 1)) + from by module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [hcomm d ![] 1 1, show h.higgs ![] 1 * h.barHiggs d 1 = (2⁻¹ : ℂ) • + ((h.higgs ![] 0 * h.barHiggs d 0 + h.higgs ![] 1 * h.barHiggs d 1) + - (h.higgs ![] 0 * h.barHiggs d 0 - h.higgs ![] 1 * h.barHiggs d 1)) + from by module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + + +noncomputable def massWeightEightPermDecomposition : + SU2PermDecomposition rep (piece rep (h.massWeightSubmodule 8) 0) where + piece := fun w => + if w = 0 then + (⨆ (d : Fin 2 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs ![] 0 + + h.higgs d 1 * h.barHiggs ![] 1)) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ (h.higgs ![] 0 * h.barHiggs d 0 + + h.higgs ![] 1 * h.barHiggs d 1)) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs d2 0 + + h.higgs d 1 * h.barHiggs d2 1)) ⊔ + ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) ⊔ + ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1) + else if w = 2 then + (⨆ (d : Fin 2 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs ![] 0 + - h.higgs d 1 * h.barHiggs ![] 1)) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ (h.higgs ![] 0 * h.barHiggs d 0 + - h.higgs ![] 1 * h.barHiggs d 1)) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ (h.higgs d 0 * h.barHiggs d2 0 + - h.higgs d 1 * h.barHiggs d2 1)) ⊔ + ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + - h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) + else ⊥ + piece_le := by + have key : ∀ (s : ℂ) (S : Submodule ℂ B), S ≤ Module.End.eigenspace (rep gaugeSU2Perm) s → + ∀ x ∈ S, rep gaugeSU2Perm x = s • x := + fun s S hS x hx => Module.End.mem_eigenspace_iff.mp (hS hx) + intro k x hx + rcases eq_or_ne k 0 with rfl | hk0 + · rw [if_pos rfl] at hx + refine key _ _ ?_ x hx + refine sup_le (sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) ?_) ?_ <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_add, su2PermSign_zero, one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_add, su2PermSign_zero, one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_add, su2PermSign_zero, one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_quartic_add, su2PermSign_zero, one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_quartic_mixed, su2PermSign_zero, one_smul]) + · rcases eq_or_ne k 2 with rfl | hk2 + · rw [if_neg hk0, if_pos rfl] at hx + refine key _ _ ?_ x hx + refine sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) ?_ <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_sub, su2PermSign_two, neg_one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_sub, su2PermSign_two, neg_one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_higgsBarHiggs_sub, su2PermSign_two, neg_one_smul]) + · exact Module.End.mem_eigenspace_iff.mpr + (by rw [h.rep_gaugeSU2Perm_quartic_sub, su2PermSign_two, neg_one_smul]) + · rw [if_neg hk0, if_neg hk2, Submodule.mem_bot] at hx + subst hx + simp + iSup_piece := by + have hcomm : ∀ {n1 n2 : ℕ} (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)) + (a b : Fin 2), h.barHiggs d1 a * h.higgs d2 b = h.higgs d2 b * h.barHiggs d1 a := + fun d1 d2 a b => ((h.H_comm_barH _ _ _ _ _ _).symm).eq + rw [h.massWeightSubmodule_eight_peice_zero] + have hcases : ∀ j : ZMod 4, j = 0 ∨ j = 1 ∨ j = 2 ∨ j = 3 := by decide + refine le_antisymm (iSup_le fun k => ?_) ?_ + · rcases hcases k with rfl | rfl | rfl | rfl + · rw [if_pos rfl] + refine sup_le (sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) ?_) ?_ <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))))) + · rw [← hcomm d ![] 0 0, ← hcomm d ![] 1 1] + exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))) + · exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _)))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _))))))) + · exact add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + · exact Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · rw [if_neg (by decide), if_pos rfl] + refine sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) ?_ <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))))) + · rw [← hcomm d ![] 0 0, ← hcomm d ![] 1 1] + exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))))) + · exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _)))))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _))))))) + · exact sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + · rw [if_neg (by decide), if_neg (by decide)] + exact bot_le + · refine le_trans ?_ (sup_le (le_iSup _ (0 : ZMod 4)) (le_iSup _ (2 : ZMod 4))) + rw [if_pos rfl, if_neg (by decide : ¬(2 : ZMod 4) = 0), if_pos rfl] + set qp := h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 with hqp + set qm := h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + - h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 with hqm + refine sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le (sup_le + (iSup_le fun d => ?_) (iSup_le fun d => ?_)) (iSup_le fun d => ?_)) + (iSup_le fun d => ?_)) (iSup_le fun d => iSup_le fun d2 => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) ?_) ?_) ?_ <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · rw [show h.higgs d 0 * h.barHiggs ![] 0 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs ![] 0 + h.higgs d 1 * h.barHiggs ![] 1) + + (h.higgs d 0 * h.barHiggs ![] 0 - h.higgs d 1 * h.barHiggs ![] 1)) + from by module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + · rw [show h.higgs d 1 * h.barHiggs ![] 1 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs ![] 0 + h.higgs d 1 * h.barHiggs ![] 1) + - (h.higgs d 0 * h.barHiggs ![] 0 - h.higgs d 1 * h.barHiggs ![] 1)) + from by module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + · rw [hcomm d ![] 0 0, show h.higgs ![] 0 * h.barHiggs d 0 = (2⁻¹ : ℂ) • + ((h.higgs ![] 0 * h.barHiggs d 0 + h.higgs ![] 1 * h.barHiggs d 1) + + (h.higgs ![] 0 * h.barHiggs d 0 - h.higgs ![] 1 * h.barHiggs d 1)) + from by module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + · rw [hcomm d ![] 1 1, show h.higgs ![] 1 * h.barHiggs d 1 = (2⁻¹ : ℂ) • + ((h.higgs ![] 0 * h.barHiggs d 0 + h.higgs ![] 1 * h.barHiggs d 1) + - (h.higgs ![] 0 * h.barHiggs d 0 - h.higgs ![] 1 * h.barHiggs d 1)) + from by module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))))) + · rw [show h.higgs d 0 * h.barHiggs d2 0 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs d2 0 + h.higgs d 1 * h.barHiggs d2 1) + + (h.higgs d 0 * h.barHiggs d2 0 - h.higgs d 1 * h.barHiggs d2 1)) + from by module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem d + (Submodule.mem_iSup_of_mem d2 (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d + (Submodule.mem_iSup_of_mem d2 (Submodule.mem_span_singleton_self _))))))) + · rw [show h.higgs d 1 * h.barHiggs d2 1 = (2⁻¹ : ℂ) • + ((h.higgs d 0 * h.barHiggs d2 0 + h.higgs d 1 * h.barHiggs d2 1) + - (h.higgs d 0 * h.barHiggs d2 0 - h.higgs d 1 * h.barHiggs d2 1)) + from by module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_iSup_of_mem d + (Submodule.mem_iSup_of_mem d2 (Submodule.mem_span_singleton_self _))))))) + (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d + (Submodule.mem_iSup_of_mem d2 (Submodule.mem_span_singleton_self _))))))) + · rw [show h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + = (2⁻¹ : ℂ) • (qp + qm) from by rw [hqp, hqm]; module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_right + (Submodule.mem_span_singleton_self _)))) + · exact Submodule.mem_sup_left + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + · rw [show h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 + = (2⁻¹ : ℂ) • (qp - qm) from by rw [hqp, hqm]; module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_span_singleton_self _)))) + (Submodule.mem_sup_right (Submodule.mem_sup_right + (Submodule.mem_span_singleton_self _)))) + +/-! + +### C.3. The full invariance lemmas under the Gauge group for weight 4, 6, 8 + +-/ + + +lemma mem_of_mem_massWeightSubmodule_four_of_invariant {w : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule 4) (hginv : ∀ g : GaugeGroupI, rep g x = x) : + x ∈ ℂ ∙ h.dotGaugeHiggs ![] ![] := by + have hspan : x ∈ (h.massWeightFourPermDecomposition).piece 0 := + SU2PermDecomposition.mem_zero_of_invariant h.massWeightFourPermDecomposition + (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hginv) hginv + dsimp only [massWeightFourPermDecomposition] at hspan + rw [if_pos rfl] at hspan + exact hspan + +lemma mem_of_mem_massWeightSubmodule_six_of_invariant {w : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule 6) (hginv : ∀ g : GaugeGroupI, rep g x = x) : + x ∈ (⨆ (d : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs ![] d) := by + have hspan : x ∈ (h.massWeightSixPermDecomposition).piece 0 := + SU2PermDecomposition.mem_zero_of_invariant h.massWeightSixPermDecomposition + (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hginv) hginv + dsimp only [massWeightSixPermDecomposition] at hspan + rw [if_pos rfl] at hspan + exact hspan + +lemma mem_of_mem_massWeightSubmodule_eight_of_invariant {w : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule 8) (hginv : ∀ g : GaugeGroupI, rep g x = x) : + x ∈ (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs ![] d) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs d d2) ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := by + -- the two sieves: `x` lies in the Weyl-grade-zero part of the gauge-weight-zero piece + have hspan : x ∈ (h.massWeightEightPermDecomposition).piece 0 := + SU2PermDecomposition.mem_zero_of_invariant h.massWeightEightPermDecomposition + (GaugeWeightDecomposition.mem_zero_of_invariant _ hx hginv) hginv + dsimp only [massWeightEightPermDecomposition] at hspan + rw [if_pos rfl, sup_assoc] at hspan + -- commutation lemmas for sorting quartic monomials + have hHH : ∀ i j, h.higgs ![] i * h.higgs ![] j = h.higgs ![] j * h.higgs ![] i := + fun i j => (h.H_comm_H _ _ _ _ _ _).eq + have hbH : ∀ i j, h.barHiggs ![] i * h.higgs ![] j = h.higgs ![] j * h.barHiggs ![] i := + fun i j => (h.H_comm_barH _ _ _ _ _ _).symm.eq + have hbb : ∀ i j, h.barHiggs ![] i * h.barHiggs ![] j + = h.barHiggs ![] j * h.barHiggs ![] i := fun i j => (h.barH_comm_barH _ _ _ _ _ _).eq + have hHH' : ∀ i j (y : B), h.higgs ![] i * (h.higgs ![] j * y) + = h.higgs ![] j * (h.higgs ![] i * y) := fun i j y => by rw [← mul_assoc, hHH, mul_assoc] + have hbH' : ∀ i j (y : B), h.barHiggs ![] i * (h.higgs ![] j * y) + = h.higgs ![] j * (h.barHiggs ![] i * y) := fun i j y => by rw [← mul_assoc, hbH, mul_assoc] + -- basis change in the quartic sector: `{u + w, v}` spans the same plane as `{(H†H)², (H†σ³H)²}` + have hmm : h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] + = (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) + + (2 : ℂ) • (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1) := by + rw [dotGaugeHiggs] + simp only [add_mul, mul_add, mul_assoc, hHH', hbH', hbb] + match_scalars <;> norm_num + have htt : (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + = (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1) + - (2 : ℂ) • (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1) := by + simp only [sub_mul, mul_sub, mul_assoc, hHH', hbH', hbb] + match_scalars <;> norm_num + have hquart : (ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1)) ⊔ + (ℂ ∙ (h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1)) + = (ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) ⊔ + (ℂ ∙ ((h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1))) := by + refine le_antisymm (sup_le ?_ ?_) (sup_le ?_ ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · rw [show h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 0 * h.barHiggs ![] 0 + + h.higgs ![] 1 * h.barHiggs ![] 1 * h.higgs ![] 1 * h.barHiggs ![] 1 + = (2⁻¹ : ℂ) • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] + + (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + from by rw [hmm, htt]; module] + exact Submodule.smul_mem _ _ (add_mem + (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + · rw [show h.higgs ![] 0 * h.barHiggs ![] 0 * h.higgs ![] 1 * h.barHiggs ![] 1 + = ((4 : ℂ)⁻¹) • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] + - (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + from by rw [hmm, htt]; module] + exact Submodule.smul_mem _ _ (sub_mem + (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + · rw [hmm] + exact add_mem (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + (Submodule.smul_mem _ _ (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + · rw [htt] + exact sub_mem (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + (Submodule.smul_mem _ _ (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + have hspan2 : x ∈ (((⨆ d : Fin 2 → (Fin 1 ⊕ Fin 3), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ d : Fin 2 → (Fin 1 ⊕ Fin 3), ℂ ∙ h.dotGaugeHiggs ![] d)) ⊔ + (⨆ d : Fin 1 → (Fin 1 ⊕ Fin 3), ⨆ d2 : Fin 1 → (Fin 1 ⊕ Fin 3), + ℂ ∙ h.dotGaugeHiggs d d2)) ⊔ + ((ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) ⊔ + (ℂ ∙ ((h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)))) := by + rw [hquart] at hspan + exact hspan + -- the cyclic `SU(2)` element implementing the quarter-turn about the diagonal axis + have hmem : !![(1 - Complex.I) / 2, (-1 - Complex.I) / 2; + (1 - Complex.I) / 2, (1 + Complex.I) / 2] ∈ specialUnitaryGroup (Fin 2) ℂ := by + rw [Matrix.mem_specialUnitaryGroup_iff] + refine ⟨?_, ?_⟩ + · rw [Matrix.mem_unitaryGroup_iff] + ext a b + fin_cases a <;> fin_cases b <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, star_eq_conjTranspose, + Matrix.conjTranspose_apply, map_div₀, map_ofNat, + Complex.ext_iff] <;> norm_num + · rw [Matrix.det_fin_two_of] + simp [Complex.ext_iff] + norm_num + set g : GaugeGroupI := ⟨1, ⟨_, hmem⟩, 1⟩ with hg + have hgmat : ((g⁻¹).toSU2 : Matrix (Fin 2) (Fin 2) ℂ) + = !![(1 + Complex.I)/2, (1 + Complex.I)/2; (-1 + Complex.I)/2, (1 - Complex.I)/2] := by + rw [map_inv, ← Matrix.star_eq_inv, Matrix.specialUnitaryGroup.coe_star] + ext a b + fin_cases a <;> fin_cases b <;> + simp [hg, GaugeGroupI.toSU2, Complex.conj_I, Complex.ext_iff] + have hU1 : ((g⁻¹).toU1 : ℂ) = 1 := by simp [hg, GaugeGroupI.toU1] + have hH0 : rep g (h.higgs ![] 0) + = ((1 + Complex.I)/2) • h.higgs ![] 0 + ((1 + Complex.I)/2) • h.higgs ![] 1 := by + rw [h.rep_higgsComponent, Fin.sum_univ_two, hU1, hgmat] + simp + have hH1 : rep g (h.higgs ![] 1) + = ((-1 + Complex.I)/2) • h.higgs ![] 0 + ((1 - Complex.I)/2) • h.higgs ![] 1 := by + rw [h.rep_higgsComponent, Fin.sum_univ_two, hU1, hgmat] + simp + have hB0 : rep g (h.barHiggs ![] 0) + = ((1 - Complex.I)/2) • h.barHiggs ![] 0 + ((1 - Complex.I)/2) • h.barHiggs ![] 1 := by + rw [h.rep_barHiggsComponent, Fin.sum_univ_two, hU1, hgmat] + simp [map_div₀, Complex.conj_I, map_ofNat] + module + have hB1 : rep g (h.barHiggs ![] 1) + = ((-1 - Complex.I)/2) • h.barHiggs ![] 0 + ((1 + Complex.I)/2) • h.barHiggs ![] 1 := by + rw [h.rep_barHiggsComponent, Fin.sum_univ_two, hU1, hgmat] + simp [map_div₀, Complex.conj_I, map_ofNat] + module + -- the triplet term cycles: `n₃ ↦ n₁ ↦ i n₂`, and the Fierz identity closes the orbit + have hn3 : rep g (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + = h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0 := by + rw [map_sub, h.rep_mul, h.rep_mul, hH0, hB0, hH1, hB1] + simp only [add_mul, mul_add, smul_mul_assoc, mul_smul_comm] + match_scalars <;> simp [Complex.ext_iff] <;> norm_num + have hn1 : rep g (h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0) + = Complex.I • (h.higgs ![] 0 * h.barHiggs ![] 1 - h.higgs ![] 1 * h.barHiggs ![] 0) := by + rw [map_add, h.rep_mul, h.rep_mul, hH0, hB0, hH1, hB1] + simp only [add_mul, mul_add, smul_mul_assoc, mul_smul_comm, smul_sub] + match_scalars <;> simp [Complex.ext_iff] <;> norm_num + have fierz : (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + + (h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0) + * (h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0) + + (Complex.I • (h.higgs ![] 0 * h.barHiggs ![] 1 - h.higgs ![] 1 * h.barHiggs ![] 0)) + * (Complex.I • (h.higgs ![] 0 * h.barHiggs ![] 1 - h.higgs ![] 1 * h.barHiggs ![] 0)) + = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := by + rw [dotGaugeHiggs] + simp only [sub_mul, mul_sub, add_mul, mul_add, smul_mul_assoc, mul_smul_comm, + mul_assoc, hHH', hbH', hbb] + match_scalars <;> simp [Complex.ext_iff] + have hT3 : ∀ y : B, rep (g * g) y = rep g (rep g y) := by + intro y + rw [map_mul] + rfl + have e1 : rep g ((h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + = (h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0) + * (h.higgs ![] 0 * h.barHiggs ![] 1 + h.higgs ![] 1 * h.barHiggs ![] 0) := by + rw [h.rep_mul, hn3] + have e2 : rep (g * g) ((h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1)) + = (Complex.I • (h.higgs ![] 0 * h.barHiggs ![] 1 - h.higgs ![] 1 * h.barHiggs ![] 0)) + * (Complex.I • (h.higgs ![] 0 * h.barHiggs ![] 1 - h.higgs ![] 1 * h.barHiggs ![] 0)) := by + rw [hT3, e1, h.rep_mul, hn1] + have hmm2 : ∀ k : GaugeGroupI, rep k (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) + = h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := fun k => by + rw [h.rep_mul, h.rep_dotGaugeHiggs_invariant] + -- averaging over `{1, g, g²}` projects onto the genuinely invariant span + set T : B →ₗ[ℂ] B := LinearMap.id + rep g + rep (g * g) with hT + have hTapp : ∀ y : B, T y = y + rep g y + rep (g * g) y := fun y => rfl + have hmaple : Submodule.map T ((((⨆ d : Fin 2 → (Fin 1 ⊕ Fin 3), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ d : Fin 2 → (Fin 1 ⊕ Fin 3), ℂ ∙ h.dotGaugeHiggs ![] d)) ⊔ + (⨆ d : Fin 1 → (Fin 1 ⊕ Fin 3), ⨆ d2 : Fin 1 → (Fin 1 ⊕ Fin 3), + ℂ ∙ h.dotGaugeHiggs d d2)) ⊔ + ((ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) ⊔ + (ℂ ∙ ((h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1) + * (h.higgs ![] 0 * h.barHiggs ![] 0 - h.higgs ![] 1 * h.barHiggs ![] 1))))) + ≤ (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs ![] d) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs d d2) ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := by + simp only [Submodule.map_sup, Submodule.map_iSup, Submodule.map_span, Set.image_singleton] + refine sup_le (sup_le (sup_le (iSup_le fun d => ?_) (iSup_le fun d => ?_)) + (iSup_le fun d => iSup_le fun d2 => ?_)) (sup_le ?_ ?_) <;> + rw [Submodule.span_le, Set.singleton_subset_iff] + · rw [hTapp, h.rep_dotGaugeHiggs_invariant, h.rep_dotGaugeHiggs_invariant] + exact add_mem (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [hTapp, h.rep_dotGaugeHiggs_invariant, h.rep_dotGaugeHiggs_invariant] + exact add_mem (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _))))) + · rw [hTapp, h.rep_dotGaugeHiggs_invariant, h.rep_dotGaugeHiggs_invariant] + exact add_mem (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _)))))) + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.mem_iSup_of_mem d (Submodule.mem_iSup_of_mem d2 + (Submodule.mem_span_singleton_self _))))) + · rw [hTapp, hmm2, hmm2] + exact add_mem (add_mem + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + · rw [hTapp, e1, e2, fierz] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + have hfin := hmaple ⟨x, hspan2, rfl⟩ + rw [hTapp, hginv, hginv] at hfin + have hfin' := Submodule.smul_mem _ ((3 : ℂ)⁻¹) hfin + rwa [show ((3 : ℂ)⁻¹) • (x + x + x) = x from by module] at hfin' + +/-! + +### C.4. The full gauge invariant submodule up to mass weight 8 + +-/ + +noncomputable def gaugeInvariantOfMassDim (M : ℕ) : Submodule ℂ B := + h.massWeightSubmodule M ⊓ Representation.invariants rep + +lemma gaugeInvariantOfMassDim_four_eq : + h.gaugeInvariantOfMassDim 4 = ℂ ∙ h.dotGaugeHiggs ![] ![] := by + refine le_antisymm (fun x hx => + h.mem_of_mem_massWeightSubmodule_four_of_invariant (w := 0) hx.1 hx.2) ?_ + rw [Submodule.span_singleton_le_iff_mem] + refine ⟨?_, fun g => h.rep_dotGaugeHiggs_invariant g ![] ![]⟩ + have hH : ∀ i, h.higgs ![] i ∈ h.massWeightSubmodule 2 := fun i => + h.massWeightSubmodule_higgsSubmodule_le 0 + (Submodule.mem_iSup_of_mem ![] (LinearMap.mem_range_self _ _)) + have hbH : ∀ i, h.barHiggs ![] i ∈ h.massWeightSubmodule 2 := fun i => + h.massWeightSubmodule_barHiggsSubmodule_le 0 + (Submodule.mem_iSup_of_mem ![] (LinearMap.mem_range_self _ _)) + rw [dotGaugeHiggs] + exact add_mem (h.massWeightSubmodule_mul_le 2 2 (Submodule.mul_mem_mul (hH 0) (hbH 0))) + (h.massWeightSubmodule_mul_le 2 2 (Submodule.mul_mem_mul (hH 1) (hbH 1))) + +lemma gaugeInvariantOfMassDim_six_eq : + h.gaugeInvariantOfMassDim 6 = (⨆ (d : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ (d : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs ![] d) := by + have hH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2), + h.higgs d i ∈ h.massWeightSubmodule (2 * (1 + n)) := fun n d i => + h.massWeightSubmodule_higgsSubmodule_le n + (Submodule.mem_iSup_of_mem d (LinearMap.mem_range_self _ _)) + have hbH : ∀ (n : ℕ) (d : Fin n → (Fin 1 ⊕ Fin 3)) (i : Fin 2), + h.barHiggs d i ∈ h.massWeightSubmodule (2 * (1 + n)) := fun n d i => + h.massWeightSubmodule_barHiggsSubmodule_le n + (Submodule.mem_iSup_of_mem d (LinearMap.mem_range_self _ _)) + refine le_antisymm (fun x hx => + h.mem_of_mem_massWeightSubmodule_six_of_invariant (w := 0) hx.1 hx.2) (sup_le ?_ ?_) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + refine ⟨?_, fun g => h.rep_dotGaugeHiggs_invariant g d ![]⟩ + rw [dotGaugeHiggs] + exact add_mem + (h.massWeightSubmodule_mul_le 4 2 (Submodule.mul_mem_mul (hH 1 d 0) (hbH 0 ![] 0))) + (h.massWeightSubmodule_mul_le 4 2 (Submodule.mul_mem_mul (hH 1 d 1) (hbH 0 ![] 1))) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + refine ⟨?_, fun g => h.rep_dotGaugeHiggs_invariant g ![] d⟩ + rw [dotGaugeHiggs] + exact add_mem + (h.massWeightSubmodule_mul_le 2 4 (Submodule.mul_mem_mul (hH 0 ![] 0) (hbH 1 d 0))) + (h.massWeightSubmodule_mul_le 2 4 (Submodule.mul_mem_mul (hH 0 ![] 1) (hbH 1 d 1))) + +lemma gaugeInvariantOfMassDim_eight_eq : + h.gaugeInvariantOfMassDim 8 = (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs d ![]) ⊔ + (⨆ (d : Fin 2 → _), ℂ ∙ h.dotGaugeHiggs ![] d) ⊔ + (⨆ (d : Fin 1 → _), ⨆ (d2 : Fin 1 → _), ℂ ∙ h.dotGaugeHiggs d d2) ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![] := by + have hdot : ∀ {n1 n2 : ℕ} (d1 : Fin n1 → (Fin 1 ⊕ Fin 3)) (d2 : Fin n2 → (Fin 1 ⊕ Fin 3)), + h.dotGaugeHiggs d1 d2 ∈ h.massWeightSubmodule (2 * (1 + n1) + 2 * (1 + n2)) := by + intro n1 n2 d1 d2 + have hH : ∀ i, h.higgs d1 i ∈ h.massWeightSubmodule (2 * (1 + n1)) := fun i => + h.massWeightSubmodule_higgsSubmodule_le n1 + (Submodule.mem_iSup_of_mem d1 (LinearMap.mem_range_self _ _)) + have hbH : ∀ i, h.barHiggs d2 i ∈ h.massWeightSubmodule (2 * (1 + n2)) := fun i => + h.massWeightSubmodule_barHiggsSubmodule_le n2 + (Submodule.mem_iSup_of_mem d2 (LinearMap.mem_range_self _ _)) + rw [dotGaugeHiggs] + exact add_mem (h.massWeightSubmodule_mul_le _ _ (Submodule.mul_mem_mul (hH 0) (hbH 0))) + (h.massWeightSubmodule_mul_le _ _ (Submodule.mul_mem_mul (hH 1) (hbH 1))) + refine le_antisymm (fun x hx => + h.mem_of_mem_massWeightSubmodule_eight_of_invariant (w := 0) hx.1 hx.2) + (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact ⟨hdot d ![], fun g => h.rep_dotGaugeHiggs_invariant g d ![]⟩ + · refine iSup_le fun d => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact ⟨hdot ![] d, fun g => h.rep_dotGaugeHiggs_invariant g ![] d⟩ + · refine iSup_le fun d => iSup_le fun d2 => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact ⟨hdot d d2, fun g => h.rep_dotGaugeHiggs_invariant g d d2⟩ + · rw [Submodule.span_singleton_le_iff_mem] + exact ⟨h.massWeightSubmodule_mul_le 4 4 (Submodule.mul_mem_mul (hdot ![] ![]) (hdot ![] ![])), + fun g => by rw [h.rep_mul, h.rep_dotGaugeHiggs_invariant]⟩ + +/-! + +## F. Aside: WeightDecomposition +-/ + + +structure WeightDecompositionLE {K : Type u_1} [Field K] [Algebra ℝ K] {M : Type u_2} + [AddCommGroup M] [Module K M] (rep : Representation K SL(2, ℂ) M) (i : Fin 3) + (V : Submodule K M) where + /-- The weight-`k` piece of the decomposition. -/ + piece : ℤ → Submodule K M + /-- The finite set of weights that occur. -/ + supp : Finset ℤ + piece_le : ∀ k, piece k ≤ boostWeightSubmodule rep i k + piece_eq_bot : ∀ k ∉ supp, piece k = ⊥ + iSup_piece : V ≤ (⨆ k, piece k) + +/-- A weight decomposition of `V` covers every submodule of `V`. -/ +noncomputable def _root_.Lorentz.BoostWeight.WeightDecomposition.toLE + {K : Type*} [Field K] [Algebra ℝ K] {M : Type*} [AddCommGroup M] [Module K M] + {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {V V' : Submodule K M} + (d : WeightDecomposition rep i V) (hV' : V' ≤ V) : + WeightDecompositionLE rep i V' where + piece := d.piece + supp := d.supp + piece_le := d.piece_le + piece_eq_bot := d.piece_eq_bot + iSup_piece := hV'.trans d.iSup_piece.ge + +/-- **A weight-zero element of a covered submodule lies in the weight-zero piece**: the + boost-weight spaces are independent, so the pieces of nonzero weight cannot contribute + to it. -/ +lemma WeightDecompositionLE.mem_piece_zero_of_mem + {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [Ring A] [Algebra K A] + {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {V : Submodule K A} + (d : WeightDecompositionLE rep i V) {x : A} + (hxV : x ∈ V) (hx0 : x ∈ boostWeightSubmodule rep i 0) : x ∈ d.piece 0 := by + have hcov : x ∈ d.piece 0 ⊔ ⨆ k, ⨆ (_ : k ≠ (0 : ℤ)), d.piece k := by + refine (d.iSup_piece.trans (iSup_le fun k => ?_)) hxV + by_cases hk : k = 0 + · subst hk + exact le_sup_left + · exact le_sup_of_le_right (le_iSup₂_of_le k hk le_rfl) + obtain ⟨y, hy, z, hz, hyz⟩ := Submodule.mem_sup.1 hcov + have hz1 : z ∈ ⨆ k, ⨆ (_ : k ≠ (0 : ℤ)), boostWeightSubmodule rep i k := + (iSup₂_le fun k hk => le_iSup₂_of_le k hk (d.piece_le k)) hz + have hz0 : z ∈ boostWeightSubmodule rep i 0 := by + rw [show z = x - y from by rw [← hyz]; abel] + exact sub_mem hx0 (d.piece_le 0 hy) + have hz' : z = 0 := + Submodule.disjoint_def.1 (iSupIndep_def.1 (boostWeightSubmodule_iSupIndep rep) 0) z hz0 hz1 + rw [← hyz, hz', add_zero] + exact hy + +/-- **If zero is not among the weights, an invariant element of the covered submodule + vanishes.** -/ +lemma WeightDecompositionLE.eq_zero_of_mem_of_zero_notMem_supp + {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [Ring A] [Algebra K A] + {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {V : Submodule K A} + (d : WeightDecompositionLE rep i V) {x : A} (h0 : (0 : ℤ) ∉ d.supp) + (hxV : x ∈ V) (hx0 : x ∈ boostWeightSubmodule rep i 0) : x = 0 := by + have hx := d.mem_piece_zero_of_mem hxV hx0 + rwa [d.piece_eq_bot 0 h0, Submodule.mem_bot] at hx + +/-- **Uniqueness of boost-weight components**: if a weight-zero element is written as a sum + of two homogeneous pieces of distinct nonzero weights and a weight-zero remainder, the + homogeneous pieces vanish. -/ +lemma eq_zero_and_eq_zero_of_add_add_mem_boostWeightSubmodule + {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [Ring A] [Algebra K A] + {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {a b : ℤ} {P N R : A} + (hP : P ∈ boostWeightSubmodule rep i a) (hN : N ∈ boostWeightSubmodule rep i b) + (hR : R ∈ boostWeightSubmodule rep i 0) + (hx : P + N + R ∈ boostWeightSubmodule rep i 0) + (ha : a ≠ 0) (hb : b ≠ 0) (hab : a ≠ b) : P = 0 ∧ N = 0 := by + have hPN : P + N ∈ boostWeightSubmodule rep i 0 := by + have h1 := sub_mem hx hR + rwa [add_sub_cancel_right] at h1 + have hP0 : P = 0 := by + refine Submodule.disjoint_def.1 + (iSupIndep_def.1 (boostWeightSubmodule_iSupIndep rep) a) P hP ?_ + have h2 : P = (P + N) - N := by abel + rw [h2] + exact sub_mem + (Submodule.mem_iSup_of_mem 0 (Submodule.mem_iSup_of_mem (Ne.symm ha) hPN)) + (Submodule.mem_iSup_of_mem b (Submodule.mem_iSup_of_mem (fun hba => hab hba.symm) hN)) + refine ⟨hP0, ?_⟩ + rw [hP0, zero_add] at hPN + exact Submodule.disjoint_def.1 + (iSupIndep_def.1 (boostWeightSubmodule_iSupIndep rep) b) N hN + (Submodule.mem_iSup_of_mem 0 (Submodule.mem_iSup_of_mem (Ne.symm hb) hPN)) + + +/-! + +## D. Invariance under the Lorentz group + +Given the invariance under the the gauge group, +we now give the invariance under the Lorentz group. + +The Lorentz invariant argument is the following. +For a vector space `V` with a representation of the Lorentz group. +we decompose `V` into eigenvectors of the Lorentz boost along the `x`-axis. +`V = V₀ ⊕ V₁ ⊕ V₋₁ ⊕ V₂ ⊕ V₋₂ ⊕ ...`. +We then take a minimal extension `W` of `V₀` such that `V₀ ≤ W ≤ V` and that we can +decompose `W` based on the eigenvalues of the Lorentz boost along the `y`-axis: +`W = W₀ ⊕ W₁ ⊕ W₋₁ ⊕ W₂ ⊕ W₋₂ ⊕ ...`. +We now do the same with `W₀` finding a minimal extension `K` of `W₀` such that `W₀ ≤ K ≤ W` +and that we can decompose `K` based on the eigenvalues of the Lorentz boost along the `z`-axis: +`K = K₀ ⊕ K₁ ⊕ K₋₁ ⊕ K₂ ⊕ K₋₂ ⊕ ...`. +An element of `V` which is Lorentz invariant must be in `K₀`. +This is usually an if and only if statement. +-/ + +/-! + +### D.1. The decomposition under boost weights in the x-direction + +-/ +open Lorentz.BoostWeight + +/-- With all derivatives on the Higgs, the two-factor symbol is scaling by + `dotGaugeHiggs d ![]`. -/ +lemma dotSymbol_left (d : Fin 1 → Fin 1 ⊕ Fin 3) : + h.dotSymbol ![1, 0] d = LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs d ![]) := by + rw [dotSymbol] + congr 1 + congr 1 + exact funext fun j => j.elim0 + +/-- With all derivatives on the conjugate Higgs. -/ +lemma dotSymbol_right (d : Fin 1 → Fin 1 ⊕ Fin 3) : + h.dotSymbol ![0, 1] d = LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs ![] d) := by + rw [dotSymbol] + congr 1 + congr 1 + all_goals first + | exact funext fun j => j.elim0 + | (funext j; congr 1; exact Fin.ext (by simp)) + +@[simp] +lemma range_dotSymbol_left (d : Fin 1 → Fin 1 ⊕ Fin 3) : + (h.dotSymbol ![1, 0] d).range = ℂ ∙ h.dotGaugeHiggs d ![] := by + rw [h.dotSymbol_left d, ← LinearMap.span_singleton_eq_range] + +@[simp] +lemma range_dotSymbol_right (d : Fin 1 → Fin 1 ⊕ Fin 3) : + (h.dotSymbol ![0, 1] d).range = ℂ ∙ h.dotGaugeHiggs ![] d := by + rw [h.dotSymbol_right d, ← LinearMap.span_singleton_eq_range] + +/-- With both derivatives on the Higgs. -/ +lemma dotSymbol_left_two (d : Fin 2 → Fin 1 ⊕ Fin 3) : + h.dotSymbol ![2, 0] d = LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs d ![]) := by + rw [dotSymbol] + congr 1 + congr 1 + exact funext fun j => j.elim0 + +/-- With both derivatives on the conjugate Higgs. -/ +lemma dotSymbol_right_two (d : Fin 2 → Fin 1 ⊕ Fin 3) : + h.dotSymbol ![0, 2] d = LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs ![] d) := by + rw [dotSymbol] + congr 1 + congr 1 + all_goals first + | exact funext fun j => j.elim0 + | (funext j; congr 1; exact Fin.ext (by simp)) + +/-- With one derivative on each factor. -/ +lemma dotSymbol_one_one (d : Fin 2 → Fin 1 ⊕ Fin 3) : + h.dotSymbol ![1, 1] d = LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs ![d 0] ![d 1]) := by + rw [dotSymbol] + congr 1 + congr 1 + all_goals funext j + all_goals fin_cases j + all_goals rfl + +@[simp] +lemma range_dotSymbol_left_two (d : Fin 2 → Fin 1 ⊕ Fin 3) : + (h.dotSymbol ![2, 0] d).range = ℂ ∙ h.dotGaugeHiggs d ![] := by + rw [h.dotSymbol_left_two d, ← LinearMap.span_singleton_eq_range] + +@[simp] +lemma range_dotSymbol_right_two (d : Fin 2 → Fin 1 ⊕ Fin 3) : + (h.dotSymbol ![0, 2] d).range = ℂ ∙ h.dotGaugeHiggs ![] d := by + rw [h.dotSymbol_right_two d, ← LinearMap.span_singleton_eq_range] + +@[simp] +lemma range_dotSymbol_one_one (d : Fin 2 → Fin 1 ⊕ Fin 3) : + (h.dotSymbol ![1, 1] d).range = ℂ ∙ h.dotGaugeHiggs ![d 0] ![d 1] := by + rw [h.dotSymbol_one_one d, ← LinearMap.span_singleton_eq_range] + +/-- The underived inner product is a Lorentz scalar. -/ +lemma repLorentz_dotGaugeHiggs_nil (g : SL(2,ℂ)) : + repLorentz g (h.dotGaugeHiggs ![] ![]) = h.dotGaugeHiggs ![] ![] := by + have hq : ∀ (a b : Fin 0 → Fin 1 ⊕ Fin 3), h.dotGaugeHiggs a b = h.dotGaugeHiggs ![] ![] := + fun a b => by rw [Subsingleton.elim a ![], Subsingleton.elim b ![]] + rw [h.repLorentz_dotGaugeHiggs] + simp only [Finset.univ_unique, Finset.sum_singleton, Finset.univ_eq_empty, + Finset.prod_empty, one_mul, one_smul, hq] + +/-- **The square of the inner product as a zero-index symbol map** over `ℂ`: the quartic + term of mass weight eight carries no Lorentz index. -/ +noncomputable def quarticSymbol (_ : Fin 0 → Fin 1 ⊕ Fin 3) : ℂ →ₗ[ℂ] B := + LinearMap.toSpanSingleton ℂ B (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) + +/-- The quartic symbol rotates trivially: it has no derivative indices and is a Lorentz + scalar. -/ +lemma rotatesIndices_quarticSymbol : + IsDerivativeCollection.RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz + h.quarticSymbol := fun g d w => by + simp only [quarticSymbol, LinearMap.toSpanSingleton_apply, map_smul, Finset.univ_unique, + Finset.sum_singleton, Finset.univ_eq_empty, Finset.prod_empty, one_smul, + MonoidHom.one_apply, Module.End.one_apply] + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + +@[simp] +lemma range_quarticSymbol (d : Fin 0 → Fin 1 ⊕ Fin 3) : + (h.quarticSymbol d).range + = ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + rw [quarticSymbol, ← LinearMap.span_singleton_eq_range] + +/-- The range of a `+ + - -` combination of scalings is the span of the combination. -/ +lemma range_toSpanSingleton_add_sub_sub (x y z w : B) : + LinearMap.range (LinearMap.toSpanSingleton ℂ B x + LinearMap.toSpanSingleton ℂ B y + - LinearMap.toSpanSingleton ℂ B z - LinearMap.toSpanSingleton ℂ B w) + = ℂ ∙ (x + y - z - w) := by + rw [show LinearMap.toSpanSingleton ℂ B x + LinearMap.toSpanSingleton ℂ B y + - LinearMap.toSpanSingleton ℂ B z - LinearMap.toSpanSingleton ℂ B w + = LinearMap.toSpanSingleton ℂ B (x + y - z - w) from by + ext + simp [smul_add, smul_sub]] + rw [← LinearMap.span_singleton_eq_range] + +/-- The range of a `+ - + -` combination of scalings is the span of the combination. -/ +lemma range_toSpanSingleton_sub_add_sub (x y z w : B) : + LinearMap.range (LinearMap.toSpanSingleton ℂ B x - LinearMap.toSpanSingleton ℂ B y + + LinearMap.toSpanSingleton ℂ B z - LinearMap.toSpanSingleton ℂ B w) + = ℂ ∙ (x - y + z - w) := by + rw [show LinearMap.toSpanSingleton ℂ B x - LinearMap.toSpanSingleton ℂ B y + + LinearMap.toSpanSingleton ℂ B z - LinearMap.toSpanSingleton ℂ B w + = LinearMap.toSpanSingleton ℂ B (x - y + z - w) from by + ext + simp [smul_add, smul_sub]] + rw [← LinearMap.span_singleton_eq_range] + +/-- The span of the two-factor symbols is the gauge-invariant submodule of mass weight + six: one derivative on the Higgs or one on its conjugate. -/ +lemma iSup_range_dotSymbol_eq : + ((⨆ d, (h.dotSymbol ![1, 0] d).range) ⊔ ⨆ d, (h.dotSymbol ![0, 1] d).range) + = h.gaugeInvariantOfMassDim 6 := by + rw [h.gaugeInvariantOfMassDim_six_eq] + congr 1 + · exact iSup_congr fun d => h.range_dotSymbol_left d + · exact iSup_congr fun d => h.range_dotSymbol_right d + + +/-- **The boost-weight decomposition of the gauge-invariant terms of mass weight six.** + The two families — one derivative on the Higgs, one on its conjugate — are each a + two-factor derivative collection over `ℂ`, so each carries a decomposition; the join of + the two is the decomposition of their join. -/ +noncomputable def boostWeightZeroSix (i : Fin 3) : + WeightDecomposition repLorentz i (h.gaugeInvariantOfMassDim 6) := + ((h.isDerivativeCollection_dotSymbol.boostDecompOfNum ![1, 0] i + (trivialWeightDecomposition i)).sup + (h.isDerivativeCollection_dotSymbol.boostDecompOfNum ![0, 1] i + (trivialWeightDecomposition i))).copy h.iSup_range_dotSymbol_eq + +/-- The span of the two-derivative symbols, together with the square of the underived + inner product, is the gauge-invariant submodule of mass weight eight. -/ +lemma iSup_range_dotSymbol_eight_eq : + ((((⨆ d : Fin 2 → Fin 1 ⊕ Fin 3, (h.dotSymbol ![2, 0] d).range) ⊔ + ⨆ d : Fin 2 → Fin 1 ⊕ Fin 3, (h.dotSymbol ![0, 2] d).range) ⊔ + ⨆ d : Fin 2 → Fin 1 ⊕ Fin 3, (h.dotSymbol ![1, 1] d).range) ⊔ + ⨆ d : Fin 0 → Fin 1 ⊕ Fin 3, (h.quarticSymbol d).range) + = h.gaugeInvariantOfMassDim 8 := by + rw [h.gaugeInvariantOfMassDim_eight_eq] + congr 1 + · congr 1 + · congr 1 + · exact iSup_congr fun d => h.range_dotSymbol_left_two d + · exact iSup_congr fun d => h.range_dotSymbol_right_two d + · refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun d1 => iSup_le fun d2 => ?_) + · rw [h.range_dotSymbol_one_one d] + exact le_iSup_of_le ![d 0] (le_iSup_of_le ![d 1] le_rfl) + · refine le_iSup_of_le ![d1 0, d2 0] (le_of_eq ?_) + rw [h.range_dotSymbol_one_one] + simp only [Matrix.cons_val_zero, Matrix.cons_val_one] + rw [show ![d1 0] = d1 from funext fun j => by fin_cases j; rfl, + show ![d2 0] = d2 from funext fun j => by fin_cases j; rfl] + · refine le_antisymm (iSup_le fun d => le_of_eq (h.range_quarticSymbol d)) ?_ + exact le_iSup_of_le ![] (le_of_eq (h.range_quarticSymbol ![]).symm) + +/-- **The boost-weight decomposition of the gauge-invariant terms of mass weight eight.** + The three two-derivative families are two-factor derivative collections over `ℂ`, so + each carries a decomposition; the square of the inner product is a Lorentz scalar, + carrying its trivial decomposition; the join of the four is the decomposition of their + join. -/ +noncomputable def boostWeightZeroEight (i : Fin 3) : + WeightDecomposition repLorentz i (h.gaugeInvariantOfMassDim 8) := + ((((h.isDerivativeCollection_dotSymbol.boostDecompOfNum ![2, 0] i + (trivialWeightDecomposition i)).sup + (h.isDerivativeCollection_dotSymbol.boostDecompOfNum ![0, 2] i + (trivialWeightDecomposition i))).sup + (h.isDerivativeCollection_dotSymbol.boostDecompOfNum ![1, 1] i + (trivialWeightDecomposition i))).sup + (IsDerivativeCollection.boostDecompZero h.quarticSymbol h.rotatesIndices_quarticSymbol i + (trivialWeightDecomposition i))).copy h.iSup_range_dotSymbol_eight_eq + + +/-! + +### D.4. The zero parts of the boost weights in the x-direction + +-/ + +lemma boostWeightZeroSix_piece_zero_eq (i : Fin 3) : + (h.boostWeightZeroSix i).piece 0 = + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 1)] ![] ⊔ ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 2)] ![]) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i + 1)] ⊔ ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i+ 2)]) := by + have h1 := IsDerivativeCollection.iSup_range_lightConeDeriv_single_weight_zero + (h.dotSymbol ![1, 0]) i + have h2 := IsDerivativeCollection.iSup_range_lightConeDeriv_single_weight_zero + (h.dotSymbol ![0, 1]) i + simp only [h.range_dotSymbol_left] at h1 + simp only [h.range_dotSymbol_right] at h2 + dsimp only [boostWeightZeroSix, WeightDecomposition.copy_piece, WeightDecomposition.sup_piece] + rw [h.isDerivativeCollection_dotSymbol.boostDecompOfNum_piece_of_weight_zero ![1, 0] i + (trivialWeightDecomposition i) (by simp) (fun b hb => by simp [hb]), + h.isDerivativeCollection_dotSymbol.boostDecompOfNum_piece_of_weight_zero ![0, 1] i + (trivialWeightDecomposition i) (by simp) (fun b hb => by simp [hb])] + exact congrArg₂ (· ⊔ ·) h1 h2 + +/-- **The weight-zero piece of the mass-weight-eight decomposition.** Per two-derivative + family: the two null combinations `(D₀ ∓ Dᵢ)(D₀ ± Dᵢ)` and the four transverse pairs; + and the square of the underived inner product. -/ +lemma boostWeightZeroEight_piece_zero_eq (i : Fin 3) : + (h.boostWeightZeroEight i).piece 0 = + (((ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + + h.dotGaugeHiggs ![Sum.inl 0, Sum.inr i] ![] + - h.dotGaugeHiggs ![Sum.inr i, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr i, Sum.inr i] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inl 0, Sum.inr i] ![] + + h.dotGaugeHiggs ![Sum.inr i, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr i, Sum.inr i] ![])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 1), Sum.inr (i + 1)] ![] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 1), Sum.inr (i + 2)] ![])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 2), Sum.inr (i + 1)] ![] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 2), Sum.inr (i + 2)] ![])) ⊔ + (((ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + + h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr i] + - h.dotGaugeHiggs ![] ![Sum.inr i, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr i, Sum.inr i]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr i] + + h.dotGaugeHiggs ![] ![Sum.inr i, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr i, Sum.inr i])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i + 1), Sum.inr (i + 1)] ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i + 1), Sum.inr (i + 2)])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i + 2), Sum.inr (i + 1)] ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr (i + 2), Sum.inr (i + 2)])) ⊔ + (((ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + + h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr i] + - h.dotGaugeHiggs ![Sum.inr i] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr i] ![Sum.inr i]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr i] + + h.dotGaugeHiggs ![Sum.inr i] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr i] ![Sum.inr i])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 1)] ![Sum.inr (i + 1)] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 1)] ![Sum.inr (i + 2)])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 2)] ![Sum.inr (i + 1)] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr (i + 2)] ![Sum.inr (i + 2)])) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + have h1 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero + (h.dotSymbol ![2, 0]) i + have h2 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero + (h.dotSymbol ![0, 2]) i + have h3 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero + (h.dotSymbol ![1, 1]) i + simp only [IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_two_three, + IsDerivativeCollection.lightConeDeriv_pair_three_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + range_toSpanSingleton_add_sub_sub, range_toSpanSingleton_sub_add_sub, + ← LinearMap.span_singleton_eq_range] at h1 h2 h3 + have hq : (IsDerivativeCollection.boostDecompZero h.quarticSymbol + h.rotatesIndices_quarticSymbol i (trivialWeightDecomposition i)).piece 0 + = ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + dsimp only [IsDerivativeCollection.boostDecompZero, trivialWeightDecomposition_piece] + rw [if_pos rfl, Submodule.map_top, h.range_quarticSymbol] + dsimp only [boostWeightZeroEight, WeightDecomposition.copy_piece, + WeightDecomposition.sup_piece] + rw [h.isDerivativeCollection_dotSymbol.boostDecompOfNum_piece_of_weight_zero ![2, 0] i + (trivialWeightDecomposition i) (by simp) (fun b hb => by simp [hb]), + h.isDerivativeCollection_dotSymbol.boostDecompOfNum_piece_of_weight_zero ![0, 2] i + (trivialWeightDecomposition i) (by simp) (fun b hb => by simp [hb]), + h.isDerivativeCollection_dotSymbol.boostDecompOfNum_piece_of_weight_zero ![1, 1] i + (trivialWeightDecomposition i) (by simp) (fun b hb => by simp [hb]), hq] + exact congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) h1 h2) h3) rfl + +/-! + +### D.4. The decomposition along the x and y directions + +-/ + + +open IsDerivativeCollection in +/-- **The minimal `y`-boost covering of the `x`-weight-zero part** of the dimension-six + terms. The `z`-derivative terms have `y`-weight zero; the `y`-derivative terms are not + `y`-boost eigenvectors, so they are covered by the light-cone combinations `D₀ ∓ D₁`, + of weights `±2`. -/ +noncomputable def dimSixWeightDecompositionLE : + WeightDecompositionLE repLorentz 1 ((h.boostWeightZeroSix 0).piece 0) where + piece k := + if k = 0 then + ℂ ∙ h.dotGaugeHiggs ![Sum.inr 2] ![] ⊔ ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 2] + else if k = 2 then + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 1] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 1]) + else if k = -2 then + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 1] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 1]) + else ⊥ + supp := {-2, 0, 2} + piece_le k := by + have hbase : ∀ (F : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ →ₗ[ℂ] B) + (hF : RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz F) (κ : Fin 4), + lightConeDeriv F 1 ![κ] 1 ∈ + boostWeightSubmodule repLorentz 1 (lightConeWeight κ) := fun F hF κ => by + simpa using lightConeDeriv_mem F hF 1 ![κ] (b := 0) (w := 1) + ((trivialWeightDecomposition 1).piece_le 0 (by simp)) + have hL := hbase (h.dotSymbol ![1, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 0]) + have hR := hbase (h.dotSymbol ![0, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 1]) + split_ifs with h0 h2 hm2 + · subst h0 + refine sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + · have e := hL 2 + rw [lightConeDeriv_two, h.dotSymbol_left, show ((1 : Fin 3) + 1) = 2 from rfl, + LinearMap.toSpanSingleton_apply, one_smul, + show lightConeWeight 2 = (0 : ℤ) from rfl] at e + exact e + · have e := hR 2 + rw [lightConeDeriv_two, h.dotSymbol_right, show ((1 : Fin 3) + 1) = 2 from rfl, + LinearMap.toSpanSingleton_apply, one_smul, + show lightConeWeight 2 = (0 : ℤ) from rfl] at e + exact e + · subst h2 + refine sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + · have e := hL 0 + rw [lightConeDeriv_zero, LinearMap.sub_apply, h.dotSymbol_left, h.dotSymbol_left, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 0 = (2 : ℤ) from rfl] at e + exact e + · have e := hR 0 + rw [lightConeDeriv_zero, LinearMap.sub_apply, h.dotSymbol_right, h.dotSymbol_right, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 0 = (2 : ℤ) from rfl] at e + exact e + · subst hm2 + refine sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + · have e := hL 1 + rw [lightConeDeriv_one, LinearMap.add_apply, h.dotSymbol_left, h.dotSymbol_left, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 1 = (-2 : ℤ) from rfl] at e + exact e + · have e := hR 1 + rw [lightConeDeriv_one, LinearMap.add_apply, h.dotSymbol_right, h.dotSymbol_right, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 1 = (-2 : ℤ) from rfl] at e + exact e + · exact bot_le + piece_eq_bot k hk := by + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk + rw [if_neg hk.2.1, if_neg hk.2.2, if_neg hk.1] + iSup_piece := by + rw [h.boostWeightZeroSix_piece_zero_eq 0, show ((0 : Fin 3) + 1) = 1 from rfl, + show ((0 : Fin 3) + 2) = 2 from rfl] + set pL := h.dotGaugeHiggs ![Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 1] ![] with hpL + set mL := h.dotGaugeHiggs ![Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 1] ![] with hmL + set pR := h.dotGaugeHiggs ![] ![Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 1] with hpR + set mR := h.dotGaugeHiggs ![] ![Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 1] with hmR + refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · rw [show h.dotGaugeHiggs ![Sum.inr 1] ![] = (2⁻¹ : ℂ) • (pL - mL) from by + rw [hpL, hmL]; module] + refine Submodule.smul_mem _ _ (sub_mem (Submodule.mem_iSup_of_mem (-2) ?_) + (Submodule.mem_iSup_of_mem 2 ?_)) + · rw [if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _) + · rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _) + · refine Submodule.mem_iSup_of_mem 0 ?_ + rw [if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _) + · rw [show h.dotGaugeHiggs ![] ![Sum.inr 1] = (2⁻¹ : ℂ) • (pR - mR) from by + rw [hpR, hmR]; module] + refine Submodule.smul_mem _ _ (sub_mem (Submodule.mem_iSup_of_mem (-2) ?_) + (Submodule.mem_iSup_of_mem 2 ?_)) + · rw [if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + · rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + · refine Submodule.mem_iSup_of_mem 0 ?_ + rw [if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + + +lemma dimSixWeightDecompositionLE_piece_zero_eq : + (h.dimSixWeightDecompositionLE.piece 0) = + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr 2] ![] ⊔ ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 2]) := by + simp [dimSixWeightDecompositionLE] + + +/-- **The minimal `y`-boost pieces over the `x`-weight-zero part of the dimension-eight + terms**: per two-derivative family, the ranges of the axis-`1` light-cone symbols over + every index pair except the two mixed transverse ones — no generator of the + `x`-weight-zero part meets a mixed `z`–`x` monomial — together with the square of the + inner product at weight zero. -/ +noncomputable def dimEightPieceOne (k : ℤ) : Submodule ℂ B := + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k ∧ + ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)), + LinearMap.range (IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![2, 0]) 1 c)) ⊔ + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k ∧ + ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)), + LinearMap.range (IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![0, 2]) 1 c)) ⊔ + (⨆ (c : Fin 2 → Fin 4) (_ : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k ∧ + ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2)), + LinearMap.range (IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![1, 1]) 1 c)) ⊔ + (if k = 0 then ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) else ⊥) + +/-- Each piece is a boost eigenspace slice of its weight. -/ +lemma dimEightPieceOne_le (k : ℤ) : + h.dimEightPieceOne k ≤ boostWeightSubmodule repLorentz 1 k := by + rw [dimEightPieceOne] + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + · exact iSup₂_le fun c hc => hc.1 ▸ IsDerivativeCollection.range_lightConeDeriv_le (n := 2) + (h.dotSymbol ![2, 0]) (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 c + · exact iSup₂_le fun c hc => hc.1 ▸ IsDerivativeCollection.range_lightConeDeriv_le (n := 2) + (h.dotSymbol ![0, 2]) (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 c + · exact iSup₂_le fun c hc => hc.1 ▸ IsDerivativeCollection.range_lightConeDeriv_le (n := 2) + (h.dotSymbol ![1, 1]) (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 c + · split_ifs with hk + · subst hk + rw [Submodule.span_singleton_le_iff_mem] + refine mem_boostWeightSubmodule.2 fun t ht => ?_ + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + simp + · exact bot_le + +/-- The pieces vanish outside the weights `{-4, -2, 0, 2, 4}`. -/ +lemma dimEightPieceOne_eq_bot (k : ℤ) (hk : k ∉ ({-4, -2, 0, 2, 4} : Finset ℤ)) : + h.dimEightPieceOne k = ⊥ := by + have hall : ∀ c : Fin 2 → Fin 4, + (∑ j, IsDerivativeCollection.lightConeWeight (c j)) ∈ ({-4, -2, 0, 2, 4} : Finset ℤ) := by + decide + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk + rw [dimEightPieceOne] + refine le_bot_iff.1 (sup_le (sup_le (sup_le ?_ ?_) ?_) ?_) + · exact iSup₂_le fun c hc => absurd (hc.1 ▸ hall c) (by + simp [Finset.mem_insert, Finset.mem_singleton, hk.1, hk.2.1, hk.2.2.1, hk.2.2.2.1, + hk.2.2.2.2]) + · exact iSup₂_le fun c hc => absurd (hc.1 ▸ hall c) (by + simp [Finset.mem_insert, Finset.mem_singleton, hk.1, hk.2.1, hk.2.2.1, hk.2.2.2.1, + hk.2.2.2.2]) + · exact iSup₂_le fun c hc => absurd (hc.1 ▸ hall c) (by + simp [Finset.mem_insert, Finset.mem_singleton, hk.1, hk.2.1, hk.2.2.1, hk.2.2.2.1, + hk.2.2.2.2]) + · rw [if_neg hk.2.2.1] + +/-- **A two-derivative Higgs monomial avoiding the mixed transverse pair lies in the join + of the minimal pieces**: the disallowed light-cone indices carry vanishing coefficient + in its light-cone expansion. -/ +lemma mem_iSup_dimEightPieceOne_left (d : Fin 2 → Fin 1 ⊕ Fin 3) + (h1 : ¬(d 0 = Sum.inr 2 ∧ d 1 = Sum.inr 0)) (h2 : ¬(d 0 = Sum.inr 0 ∧ d 1 = Sum.inr 2)) : + h.dotGaugeHiggs d ![] ∈ ⨆ k, h.dimEightPieceOne k := by + have he : h.dotGaugeHiggs d ![] = ∑ c : Fin 2 → Fin 4, + (∏ j, IsDerivativeCollection.lightConeCoeffInv 1 (d j) (c j)) • + IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![2, 0]) 1 c 1 := + calc h.dotGaugeHiggs d ![] = h.dotSymbol ![2, 0] d 1 := by + rw [h.dotSymbol_left_two, LinearMap.toSpanSingleton_apply, one_smul] + _ = _ := by + rw [IsDerivativeCollection.eq_sum_lightConeDeriv (n := 2) (h.dotSymbol ![2, 0]) 1 d] + simp only [LinearMap.coe_sum, Finset.sum_apply, LinearMap.smul_apply] + rw [he] + refine sum_mem fun c _ => ?_ + by_cases hc : ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2) + · refine Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem + (∑ j, IsDerivativeCollection.lightConeWeight (c j)) ?_) + rw [dimEightPieceOne] + refine Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left ?_)) + exact Submodule.mem_iSup_of_mem c (Submodule.mem_iSup_of_mem ⟨rfl, hc⟩ + (LinearMap.mem_range_self _ 1)) + · rw [not_and_or, not_not, not_not] at hc + rcases hc with ⟨h20, h13⟩ | ⟨h30, h12⟩ + · rcases not_and_or.1 h1 with hd | hd + · rw [Fin.prod_univ_two, h20, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h13, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + · rcases not_and_or.1 h2 with hd | hd + · rw [Fin.prod_univ_two, h30, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h12, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + +/-- As `mem_iSup_dimEightPieceOne_left`, for the conjugate-Higgs family. -/ +lemma mem_iSup_dimEightPieceOne_right (d : Fin 2 → Fin 1 ⊕ Fin 3) + (h1 : ¬(d 0 = Sum.inr 2 ∧ d 1 = Sum.inr 0)) (h2 : ¬(d 0 = Sum.inr 0 ∧ d 1 = Sum.inr 2)) : + h.dotGaugeHiggs ![] d ∈ ⨆ k, h.dimEightPieceOne k := by + have he : h.dotGaugeHiggs ![] d = ∑ c : Fin 2 → Fin 4, + (∏ j, IsDerivativeCollection.lightConeCoeffInv 1 (d j) (c j)) • + IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![0, 2]) 1 c 1 := + calc h.dotGaugeHiggs ![] d = h.dotSymbol ![0, 2] d 1 := by + rw [h.dotSymbol_right_two, LinearMap.toSpanSingleton_apply, one_smul] + _ = _ := by + rw [IsDerivativeCollection.eq_sum_lightConeDeriv (n := 2) (h.dotSymbol ![0, 2]) 1 d] + simp only [LinearMap.coe_sum, Finset.sum_apply, LinearMap.smul_apply] + rw [he] + refine sum_mem fun c _ => ?_ + by_cases hc : ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2) + · refine Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem + (∑ j, IsDerivativeCollection.lightConeWeight (c j)) ?_) + rw [dimEightPieceOne] + refine Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right ?_)) + exact Submodule.mem_iSup_of_mem c (Submodule.mem_iSup_of_mem ⟨rfl, hc⟩ + (LinearMap.mem_range_self _ 1)) + · rw [not_and_or, not_not, not_not] at hc + rcases hc with ⟨h20, h13⟩ | ⟨h30, h12⟩ + · rcases not_and_or.1 h1 with hd | hd + · rw [Fin.prod_univ_two, h20, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h13, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + · rcases not_and_or.1 h2 with hd | hd + · rw [Fin.prod_univ_two, h30, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h12, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + +/-- As `mem_iSup_dimEightPieceOne_left`, for the mixed family. -/ +lemma mem_iSup_dimEightPieceOne_mixed (d : Fin 2 → Fin 1 ⊕ Fin 3) + (h1 : ¬(d 0 = Sum.inr 2 ∧ d 1 = Sum.inr 0)) (h2 : ¬(d 0 = Sum.inr 0 ∧ d 1 = Sum.inr 2)) : + h.dotGaugeHiggs ![d 0] ![d 1] ∈ ⨆ k, h.dimEightPieceOne k := by + have he : h.dotGaugeHiggs ![d 0] ![d 1] = ∑ c : Fin 2 → Fin 4, + (∏ j, IsDerivativeCollection.lightConeCoeffInv 1 (d j) (c j)) • + IsDerivativeCollection.lightConeDeriv (n := 2) (h.dotSymbol ![1, 1]) 1 c 1 := + calc h.dotGaugeHiggs ![d 0] ![d 1] = h.dotSymbol ![1, 1] d 1 := by + rw [h.dotSymbol_one_one, LinearMap.toSpanSingleton_apply, one_smul] + _ = _ := by + rw [IsDerivativeCollection.eq_sum_lightConeDeriv (n := 2) (h.dotSymbol ![1, 1]) 1 d] + simp only [LinearMap.coe_sum, Finset.sum_apply, LinearMap.smul_apply] + rw [he] + refine sum_mem fun c _ => ?_ + by_cases hc : ¬(c 0 = 2 ∧ c 1 = 3) ∧ ¬(c 0 = 3 ∧ c 1 = 2) + · refine Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem + (∑ j, IsDerivativeCollection.lightConeWeight (c j)) ?_) + rw [dimEightPieceOne] + refine Submodule.mem_sup_left (Submodule.mem_sup_right ?_) + exact Submodule.mem_iSup_of_mem c (Submodule.mem_iSup_of_mem ⟨rfl, hc⟩ + (LinearMap.mem_range_self _ 1)) + · rw [not_and_or, not_not, not_not] at hc + rcases hc with ⟨h20, h13⟩ | ⟨h30, h12⟩ + · rcases not_and_or.1 h1 with hd | hd + · rw [Fin.prod_univ_two, h20, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h13, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + · rcases not_and_or.1 h2 with hd | hd + · rw [Fin.prod_univ_two, h30, IsDerivativeCollection.lightConeCoeffInv_three_eq_zero + (μ := d 0) 1 (by simpa using hd), zero_mul, zero_smul] + exact Submodule.zero_mem _ + · rw [Fin.prod_univ_two, h12, IsDerivativeCollection.lightConeCoeffInv_two_eq_zero + (μ := d 1) 1 (by simpa using hd), mul_zero, zero_smul] + exact Submodule.zero_mem _ + +/-- Each piece lies in the dimension-eight sector. -/ +lemma dimEightPieceOne_le_gaugeInvariant (k : ℤ) : + h.dimEightPieceOne k ≤ h.gaugeInvariantOfMassDim 8 := by + rw [← h.iSup_range_dotSymbol_eight_eq, dimEightPieceOne] + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + · exact iSup₂_le fun c _ => + (IsDerivativeCollection.range_lightConeDeriv_le_iSup_range (n := 2) + (h.dotSymbol ![2, 0]) 1 c).trans + (le_sup_of_le_left (le_sup_of_le_left le_sup_left)) + · exact iSup₂_le fun c _ => + (IsDerivativeCollection.range_lightConeDeriv_le_iSup_range (n := 2) + (h.dotSymbol ![0, 2]) 1 c).trans + (le_sup_of_le_left (le_sup_of_le_left le_sup_right)) + · exact iSup₂_le fun c _ => + (IsDerivativeCollection.range_lightConeDeriv_le_iSup_range (n := 2) + (h.dotSymbol ![1, 1]) 1 c).trans + (le_sup_of_le_left le_sup_right) + · split_ifs with hk + · refine le_sup_of_le_right ?_ + rw [Submodule.span_singleton_le_iff_mem] + refine Submodule.mem_iSup_of_mem ![] ?_ + rw [h.range_quarticSymbol] + exact Submodule.mem_span_singleton_self _ + · exact bot_le + +/-- **The minimal `y`-boost covering of the `x`-weight-zero part** of the dimension-eight + terms. -/ +noncomputable def dimEightWeightDecompositionLE : + WeightDecompositionLE repLorentz 1 ((h.boostWeightZeroEight 0).piece 0) where + piece := h.dimEightPieceOne + supp := {-4, -2, 0, 2, 4} + piece_le := h.dimEightPieceOne_le + piece_eq_bot := h.dimEightPieceOne_eq_bot + iSup_piece := by + rw [h.boostWeightZeroEight_piece_zero_eq 0, show ((0 : Fin 3) + 1) = 1 from rfl, + show ((0 : Fin 3) + 2) = 2 from rfl] + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + · refine sup_le (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · exact sub_mem (sub_mem (add_mem + (h.mem_iSup_dimEightPieceOne_left ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact sub_mem (add_mem (sub_mem + (h.mem_iSup_dimEightPieceOne_left ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_left ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact h.mem_iSup_dimEightPieceOne_left ![Sum.inr 1, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_left ![Sum.inr 1, Sum.inr 2] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_left ![Sum.inr 2, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_left ![Sum.inr 2, Sum.inr 2] (by decide) (by decide) + · refine sup_le (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · exact sub_mem (sub_mem (add_mem + (h.mem_iSup_dimEightPieceOne_right ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact sub_mem (add_mem (sub_mem + (h.mem_iSup_dimEightPieceOne_right ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_right ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact h.mem_iSup_dimEightPieceOne_right ![Sum.inr 1, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_right ![Sum.inr 1, Sum.inr 2] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_right ![Sum.inr 2, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_right ![Sum.inr 2, Sum.inr 2] (by decide) (by decide) + · refine sup_le (sup_le (sup_le ?_ ?_) (sup_le ?_ ?_)) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · exact sub_mem (sub_mem (add_mem + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact sub_mem (add_mem (sub_mem + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inl 0, Sum.inl 0] (by decide) (by decide)) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inl 0, Sum.inr 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 0, Sum.inl 0] (by decide) (by decide))) + (h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 0, Sum.inr 0] (by decide) (by decide)) + · exact h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 1, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 1, Sum.inr 2] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 2, Sum.inr 1] (by decide) (by decide) + · exact h.mem_iSup_dimEightPieceOne_mixed ![Sum.inr 2, Sum.inr 2] (by decide) (by decide) + · rw [Submodule.span_singleton_le_iff_mem] + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceOne] + refine Submodule.mem_sup_right ?_ + rw [if_pos rfl] + exact Submodule.mem_span_singleton_self _ + +/-- **The weight-zero piece of the minimal `y`-covering**, explicitly: per family the two + `y`-null combinations and the repeated `z` and `x` monomials, and the square of the + inner product. -/ +lemma dimEightWeightDecompositionLE_piece_zero_eq : + h.dimEightWeightDecompositionLE.piece 0 = + (((ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + + h.dotGaugeHiggs ![Sum.inl 0, Sum.inr 1] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inl 0, Sum.inr 1] ![] + + h.dotGaugeHiggs ![Sum.inr 1, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]))) ⊔ + (((ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + + h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr 1] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr 1] + + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2] ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]))) ⊔ + (((ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + + h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr 1] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr 1] + + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1])) ⊔ + (ℂ ∙ h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2] ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]))) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + have h1 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero_notMixed + (h.dotSymbol ![2, 0]) 1 + have h2 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero_notMixed + (h.dotSymbol ![0, 2]) 1 + have h3 := IsDerivativeCollection.iSup_range_lightConeDeriv_pair_weight_zero_notMixed + (h.dotSymbol ![1, 1]) 1 + simp only [IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((1 : Fin 3) + 1) = 2 from rfl, show ((1 : Fin 3) + 2) = 0 from rfl, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + range_toSpanSingleton_add_sub_sub, range_toSpanSingleton_sub_add_sub, + ← LinearMap.span_singleton_eq_range] at h1 h2 h3 + show h.dimEightPieceOne 0 = _ + rw [dimEightPieceOne, if_pos rfl] + exact congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) h1 h2) h3) rfl + + + +/-! + +### D.5. The decomposition along the x, y and z directions + +-/ + +open IsDerivativeCollection in +/-- **The `z`-boost covering of the doubly-weight-zero part** of the dimension-six terms. + The remaining `z`-derivative terms lie along the boost axis, so nothing survives at + weight zero: they are covered entirely by the light-cone combinations `D₀ ∓ D₂`, of + weights `±2`. -/ +noncomputable def dimSixWeightDecompositionLELE : + WeightDecompositionLE repLorentz 2 (h.dimSixWeightDecompositionLE.piece 0) where + piece k := + if k = 2 then + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2]) + else if k = -2 then + ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 2] ![]) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 2]) + else ⊥ + supp := {-2, 2} + piece_le k := by + have hbase : ∀ (F : (Fin 1 → Fin 1 ⊕ Fin 3) → ℂ →ₗ[ℂ] B) + (hF : RotatesIndices (1 : Representation ℂ SL(2,ℂ) ℂ) repLorentz F) (κ : Fin 4), + lightConeDeriv F 2 ![κ] 1 ∈ + boostWeightSubmodule repLorentz 2 (lightConeWeight κ) := fun F hF κ => by + simpa using lightConeDeriv_mem F hF 2 ![κ] (b := 0) (w := 1) + ((trivialWeightDecomposition 2).piece_le 0 (by simp)) + have hL := hbase (h.dotSymbol ![1, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 0]) + have hR := hbase (h.dotSymbol ![0, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 1]) + split_ifs with h2 hm2 + · subst h2 + refine sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + · have e := hL 0 + rw [lightConeDeriv_zero, LinearMap.sub_apply, h.dotSymbol_left, h.dotSymbol_left, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 0 = (2 : ℤ) from rfl] at e + exact e + · have e := hR 0 + rw [lightConeDeriv_zero, LinearMap.sub_apply, h.dotSymbol_right, h.dotSymbol_right, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 0 = (2 : ℤ) from rfl] at e + exact e + · subst hm2 + refine sup_le ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + ((Submodule.span_singleton_le_iff_mem _ _).2 ?_) + · have e := hL 1 + rw [lightConeDeriv_one, LinearMap.add_apply, h.dotSymbol_left, h.dotSymbol_left, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 1 = (-2 : ℤ) from rfl] at e + exact e + · have e := hR 1 + rw [lightConeDeriv_one, LinearMap.add_apply, h.dotSymbol_right, h.dotSymbol_right, + LinearMap.toSpanSingleton_apply, LinearMap.toSpanSingleton_apply, one_smul, one_smul, + show lightConeWeight 1 = (-2 : ℤ) from rfl] at e + exact e + · exact bot_le + piece_eq_bot k hk := by + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk + rw [if_neg hk.2, if_neg hk.1] + iSup_piece := by + rw [h.dimSixWeightDecompositionLE_piece_zero_eq] + set pL := h.dotGaugeHiggs ![Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 2] ![] with hpL + set mL := h.dotGaugeHiggs ![Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2] ![] with hmL + set pR := h.dotGaugeHiggs ![] ![Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 2] with hpR + set mR := h.dotGaugeHiggs ![] ![Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2] with hmR + refine sup_le ?_ ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · rw [show h.dotGaugeHiggs ![Sum.inr 2] ![] = (2⁻¹ : ℂ) • (pL - mL) from by + rw [hpL, hmL]; module] + refine Submodule.smul_mem _ _ (sub_mem (Submodule.mem_iSup_of_mem (-2) ?_) + (Submodule.mem_iSup_of_mem 2 ?_)) + · rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _) + · rw [if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_span_singleton_self _) + · rw [show h.dotGaugeHiggs ![] ![Sum.inr 2] = (2⁻¹ : ℂ) • (pR - mR) from by + rw [hpR, hmR]; module] + refine Submodule.smul_mem _ _ (sub_mem (Submodule.mem_iSup_of_mem (-2) ?_) + (Submodule.mem_iSup_of_mem 2 ?_)) + · rw [if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + · rw [if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + + +/-- **The minimal `z`-boost pieces over the doubly-weight-zero part** of the + dimension-eight terms, built from the `z`-weight components of its generators: per + family the null square at weight `±4`, the tied null–transverse difference at `±2`, + and at weight zero the symmetric null pair together with the repeated transverse + monomials and the square of the inner product. -/ +noncomputable def dimEightPieceTwo (k : ℤ) : Submodule ℂ B := + if k = 4 then + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] + else if k = 2 then + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0]) ⊔ + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0]) ⊔ + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0]) + else if k = 0 then + ((ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] ⊔ ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2]) ⊔ + (ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] ⊔ ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2]) ⊔ + (ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] ⊔ ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2])) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) + else if k = -2 then + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1]) ⊔ + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1]) ⊔ + ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1]) + else if k = -4 then + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] ⊔ + ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] + else ⊥ + +/-- Each piece is a boost eigenspace slice of its weight. -/ +lemma dimEightPieceTwo_le (k : ℤ) : + h.dimEightPieceTwo k ≤ boostWeightSubmodule repLorentz 2 k := by + have hL := fun (c : Fin 2 → Fin 4) (k : ℤ) + (hk : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k) => + IsDerivativeCollection.lightConeDot_mem (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 c hk + have hR := fun (c : Fin 2 → Fin 4) (k : ℤ) + (hk : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k) => + IsDerivativeCollection.lightConeDot_mem (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 c hk + have hM := fun (c : Fin 2 → Fin 4) (k : ℤ) + (hk : (∑ j, IsDerivativeCollection.lightConeWeight (c j)) = k) => + IsDerivativeCollection.lightConeDot_mem (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 c hk + rw [dimEightPieceTwo] + split_ifs with h4 h2 h0 hm2 hm4 + · subst h4 + refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · exact hL _ _ (by decide) + · exact hR _ _ (by decide) + · exact hM _ _ (by decide) + · subst h2 + refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · exact sub_mem (hL _ _ (by decide)) (hL _ _ (by decide)) + · exact sub_mem (hR _ _ (by decide)) (hR _ _ (by decide)) + · exact sub_mem (hM _ _ (by decide)) (hM _ _ (by decide)) + · subst h0 + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + rotate_right + · rw [Submodule.span_singleton_le_iff_mem] + refine mem_boostWeightSubmodule.2 fun t ht => ?_ + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + simp + all_goals refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · exact add_mem (hL _ _ (by decide)) (hL _ _ (by decide)) + · exact hL _ _ (by decide) + · exact hL _ _ (by decide) + · exact add_mem (hR _ _ (by decide)) (hR _ _ (by decide)) + · exact hR _ _ (by decide) + · exact hR _ _ (by decide) + · exact add_mem (hM _ _ (by decide)) (hM _ _ (by decide)) + · exact hM _ _ (by decide) + · exact hM _ _ (by decide) + · subst hm2 + refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · exact sub_mem (hL _ _ (by decide)) (hL _ _ (by decide)) + · exact sub_mem (hR _ _ (by decide)) (hR _ _ (by decide)) + · exact sub_mem (hM _ _ (by decide)) (hM _ _ (by decide)) + · subst hm4 + refine sup_le (sup_le ?_ ?_) ?_ <;> rw [Submodule.span_singleton_le_iff_mem] + · exact hL _ _ (by decide) + · exact hR _ _ (by decide) + · exact hM _ _ (by decide) + · exact bot_le + +/-- The pieces vanish outside the weights `{-4, -2, 0, 2, 4}`. -/ +lemma dimEightPieceTwo_eq_bot (k : ℤ) (hk : k ∉ ({-4, -2, 0, 2, 4} : Finset ℤ)) : + h.dimEightPieceTwo k = ⊥ := by + simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk + rw [dimEightPieceTwo, if_neg hk.2.2.2.2, if_neg hk.2.2.2.1, if_neg hk.2.2.1, + if_neg hk.2.1, if_neg hk.1] + +set_option linter.unusedSimpArgs false in +/-- **The minimal `z`-boost covering of the doubly-weight-zero part** of the + dimension-eight terms: each generator splits into its `z`-weight components, which + generate the pieces. -/ +noncomputable def dimEightWeightDecompositionLELE : + WeightDecompositionLE repLorentz 2 (h.dimEightWeightDecompositionLE.piece 0) where + piece := h.dimEightPieceTwo + supp := {-4, -2, 0, 2, 4} + piece_le := h.dimEightPieceTwo_le + piece_eq_bot := h.dimEightPieceTwo_eq_bot + iSup_piece := by + have hL00 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 4 ?_ + rw [dimEightPieceTwo, if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + have hL03 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 2 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + have hL01 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _))))) + have hL33 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))))) + have hL22 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)))) + have hL13 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-2) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + have hL11 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-4) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)) + have hR00 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 4 ?_ + rw [dimEightPieceTwo, if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + have hR03 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 2 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + have hR01 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _))))) + have hR33 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))))) + have hR22 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)))) + have hR13 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-2) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + have hR11 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-4) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)) + have hM00 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 4 ?_ + rw [dimEightPieceTwo, if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + have hM03 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 2 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + have hM01 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_span_singleton_self _)))) + have hM33 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _)))) + have hM22 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_left (Submodule.mem_sup_right (Submodule.mem_sup_right (Submodule.mem_span_singleton_self _))) + have hM13 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-2) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + have hM11 : IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] ∈ ⨆ k, h.dimEightPieceTwo k := by + refine Submodule.mem_iSup_of_mem (-4) ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_neg (by decide), + if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + rw [h.dimEightWeightDecompositionLE_piece_zero_eq] + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + · refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · rw [show h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + + h.dotGaugeHiggs ![Sum.inl 0, Sum.inr 1] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (add_mem (sub_mem (add_mem (add_mem + (Submodule.smul_mem _ _ hL00) (Submodule.smul_mem _ _ hL03)) + (Submodule.smul_mem _ _ hL01)) hL33) (Submodule.smul_mem _ _ hL13)) + (Submodule.smul_mem _ _ hL11) + · rw [show h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inl 0, Sum.inr 1] ![] + + h.dotGaugeHiggs ![Sum.inr 1, Sum.inl 0] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (sub_mem (add_mem (sub_mem + (Submodule.smul_mem _ _ hL00) (Submodule.smul_mem _ _ hL03)) + (Submodule.smul_mem _ _ hL01)) hL33) (Submodule.smul_mem _ _ hL13)) + (Submodule.smul_mem _ _ hL11) + · rw [show h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] - (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (Submodule.smul_mem _ _ hL00) + (Submodule.smul_mem _ _ hL01)) (Submodule.smul_mem _ _ hL11) + · rw [show h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] = IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + exact hL22 + · refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · rw [show h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + + h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr 1] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (add_mem (sub_mem (add_mem (add_mem + (Submodule.smul_mem _ _ hR00) (Submodule.smul_mem _ _ hR03)) + (Submodule.smul_mem _ _ hR01)) hR33) (Submodule.smul_mem _ _ hR13)) + (Submodule.smul_mem _ _ hR11) + · rw [show h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inr 1] + + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inl 0] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (sub_mem (add_mem (sub_mem + (Submodule.smul_mem _ _ hR00) (Submodule.smul_mem _ _ hR03)) + (Submodule.smul_mem _ _ hR01)) hR33) (Submodule.smul_mem _ _ hR13)) + (Submodule.smul_mem _ _ hR11) + · rw [show h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] - (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (Submodule.smul_mem _ _ hR00) + (Submodule.smul_mem _ _ hR01)) (Submodule.smul_mem _ _ hR11) + · rw [show h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] = IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + exact hR22 + · refine sup_le (sup_le ?_ ?_) (sup_le ?_ ?_) <;> + rw [Submodule.span_singleton_le_iff_mem] + · rw [show h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + + h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr 1] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] + + (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (add_mem (sub_mem (add_mem (add_mem + (Submodule.smul_mem _ _ hM00) (Submodule.smul_mem _ _ hM03)) + (Submodule.smul_mem _ _ hM01)) hM33) (Submodule.smul_mem _ _ hM13)) + (Submodule.smul_mem _ _ hM11) + · rw [show h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inr 1] + + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inl 0] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 0]) + + (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) + - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] + - (2⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 3] - IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 1]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (sub_mem (add_mem (sub_mem + (Submodule.smul_mem _ _ hM00) (Submodule.smul_mem _ _ hM03)) + (Submodule.smul_mem _ _ hM01)) hM33) (Submodule.smul_mem _ _ hM13)) + (Submodule.smul_mem _ _ hM11) + · rw [show h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2] + = (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0] - (4⁻¹ : ℂ) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) + + (4⁻¹ : ℂ) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact add_mem (sub_mem (Submodule.smul_mem _ _ hM00) + (Submodule.smul_mem _ _ hM01)) (Submodule.smul_mem _ _ hM11) + · rw [show h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] = IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + exact hM22 + · rw [Submodule.span_singleton_le_iff_mem] + refine Submodule.mem_iSup_of_mem 0 ?_ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact Submodule.mem_sup_right (Submodule.mem_span_singleton_self _) + +set_option linter.unusedSimpArgs false in +/-- **The weight-zero piece of the minimal `z`-covering**, explicitly: per family the + symmetric null combination `dotG(tt) - dotG(zz)` and the repeated `y` and `x` + monomials, and the square of the inner product. -/ +lemma dimEightWeightDecompositionLELE_piece_zero_eq : + h.dimEightWeightDecompositionLELE.piece 0 = + ((ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] ⊔ ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) ⊔ + (ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) ⊔ + ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] ⊔ ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) ⊔ + (ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) ⊔ + ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] ⊔ ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0])) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + have hL1 : (ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0])) + = ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0] + = (2 : ℂ) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact Submodule.span_singleton_smul_eq (by norm_num : (2 : ℂ) ≠ 0).isUnit _ + have hL2 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3] = h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + have hL3 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] = h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + have hR1 : (ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0])) + = ℂ ∙ (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0] + = (2 : ℂ) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact Submodule.span_singleton_smul_eq (by norm_num : (2 : ℂ) ≠ 0).isUnit _ + have hR2 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3] = h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + have hR3 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] = h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + have hM1 : (ℂ ∙ (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0])) + = ℂ ∙ (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0] + = (2 : ℂ) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + exact Submodule.span_singleton_smul_eq (by norm_num : (2 : ℂ) ≠ 0).isUnit _ + have hM2 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3] = h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + have hM3 : (ℂ ∙ IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2]) = ℂ ∙ h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] := by + rw [show IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] = h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] from by + simp only [IsDerivativeCollection.lightConeDot, IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_three, + IsDerivativeCollection.lightConeDeriv_pair_three_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_three, + IsDerivativeCollection.lightConeDeriv_pair_three_one, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul]] + show h.dimEightPieceTwo 0 = _ + rw [dimEightPieceTwo, if_neg (by decide), if_neg (by decide), if_pos rfl] + exact congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) + (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) hL1 hL2) hL3) + (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) hR1 hR2) hR3)) + (congrArg₂ (· ⊔ ·) (congrArg₂ (· ⊔ ·) hM1 hM2) hM3)) rfl + +/-! + +### D.5. The rotational average + +The three boost sieves leave, per family, the span of `TT - ZZ`, `YY` and `XX` together +with the square of the inner product — strictly more than the invariants. The remaining +reduction uses the cyclic rotation `x → y → z → x`: averaging an invariant element over +its powers replaces the three transverse coefficients by their common mean, after which +the extreme boost-weight components along each axis tie that mean to the coefficient of +`TT`, collapsing each family onto its metric contraction. + +-/ + +/-- The cyclic permutation of the coordinate directions: time is fixed and the spatial + directions rotate `x → y → z → x`. -/ +def cycDir : Fin 1 ⊕ Fin 3 → Fin 1 ⊕ Fin 3 := Sum.map id (· + 1) + +@[simp] lemma cycDir_inl : cycDir (Sum.inl 0) = Sum.inl 0 := rfl + +@[simp] lemma cycDir_inr (m : Fin 3) : cycDir (Sum.inr m) = Sum.inr (m + 1) := rfl + +/-- Composing the cyclic direction with a two-slot index vector. -/ +lemma cycDir_comp_two (μ ν : Fin 1 ⊕ Fin 3) : + (fun j => cycDir (![μ, ν] j)) = ![cycDir μ, cycDir ν] := by + funext j + fin_cases j <;> rfl + +/-- Composing the cyclic direction with a one-slot index vector. -/ +lemma cycDir_comp_one (μ : Fin 1 ⊕ Fin 3) : + (fun j => cycDir (![μ] j)) = ![cycDir μ] := by + funext j + fin_cases j + rfl + +/-- Composing the cyclic direction with the empty index vector. -/ +lemma cycDir_comp_nil : (fun j : Fin 0 => cycDir (![] j)) = ![] := by + funext j + exact j.elim0 + +/-- **The cyclic rotation** `x → y → z → x` as an element of `SL(2,ℂ)`: the rotation by + `2π/3` about the diagonal spatial axis. -/ +noncomputable def rotationCycle : SL(2,ℂ) := + ⟨(2 : ℂ)⁻¹ • !![1 - Complex.I, -(1 + Complex.I); 1 - Complex.I, 1 + Complex.I], by + rw [Matrix.det_smul, Matrix.det_fin_two_of, Fintype.card_fin] + simp [Complex.ext_iff] + norm_num⟩ + +/-- **The Lorentz matrix of the cyclic rotation is the permutation matrix of `cycDir`.** -/ +lemma toLorentzGroup_rotationCycle_apply (a b : Fin 1 ⊕ Fin 3) : + (SL2C.toLorentzGroup rotationCycle).1 a b = if a = cycDir b then 1 else 0 := by + refine Complex.ofReal_injective ?_ + rw [SL2C.toLorentzGroup_eq_trace, PauliMatrix.trace_pauliSelfAdjoint'_mul_apply] + rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + simp [rotationCycle, cycDir, PauliMatrix.pauliSelfAdjoint', PauliMatrix.pauliMatrix, + Matrix.mul_apply, Matrix.conjTranspose_apply, Fin.sum_univ_two, + Complex.ext_iff] <;> + norm_num + +/-- **The cyclic rotation acts on inner-product monomials by cycling every derivative + index.** -/ +lemma repLorentz_rotationCycle_dotGaugeHiggs {n1 n2 : ℕ} + (d₁ : Fin n1 → Fin 1 ⊕ Fin 3) (d₂ : Fin n2 → Fin 1 ⊕ Fin 3) : + repLorentz rotationCycle (h.dotGaugeHiggs d₁ d₂) + = h.dotGaugeHiggs (fun j => cycDir (d₁ j)) (fun j => cycDir (d₂ j)) := by + have hcoef : ∀ {n : ℕ} (a d : Fin n → Fin 1 ⊕ Fin 3), + (∏ j, (((SL2C.toLorentzGroup rotationCycle).1 (a j) (d j) : ℝ) : ℂ)) + = if a = fun j => cycDir (d j) then 1 else 0 := by + intro n a d + by_cases had : a = fun j => cycDir (d j) + · rw [if_pos had] + refine Finset.prod_eq_one fun j _ => ?_ + rw [toLorentzGroup_rotationCycle_apply, if_pos (congrFun had j), Complex.ofReal_one] + · rw [if_neg had] + obtain ⟨j, hj⟩ := Function.ne_iff.1 had + refine Finset.prod_eq_zero (Finset.mem_univ j) ?_ + rw [toLorentzGroup_rotationCycle_apply, if_neg hj, Complex.ofReal_zero] + rw [h.repLorentz_dotGaugeHiggs] + simp only [hcoef] + simp [ite_smul, zero_smul, one_smul, Finset.sum_ite_eq'] + +/-- Extraction of coefficients from a three-generator span. -/ +lemma mem_span_three {v₁ v₂ v₃ x : B} (hx : x ∈ ℂ ∙ v₁ ⊔ ℂ ∙ v₂ ⊔ ℂ ∙ v₃) : + ∃ a b c : ℂ, x = a • v₁ + b • v₂ + c • v₃ := by + obtain ⟨y, hy, z, hz, hyz⟩ := Submodule.mem_sup.1 hx + obtain ⟨y₁, hy₁, y₂, hy₂, hy12⟩ := Submodule.mem_sup.1 hy + obtain ⟨a, ha⟩ := Submodule.mem_span_singleton.1 hy₁ + obtain ⟨b, hb⟩ := Submodule.mem_span_singleton.1 hy₂ + obtain ⟨c, hc⟩ := Submodule.mem_span_singleton.1 hz + exact ⟨a, b, c, by rw [← hyz, ← hy12, ← ha, ← hb, ← hc]⟩ + +/-- **The metric contraction** of the family with both derivatives on the Higgs. -/ +noncomputable def metricDotLeft : B := + h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![] + +/-- **The metric contraction** of the family with both derivatives on the conjugate + Higgs. -/ +noncomputable def metricDotRight : B := + h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2] + +/-- **The metric contraction** of the family with one derivative on each factor: the + kinetic-type term `η^{μν} (D_μ H)(D_ν H^†)`. -/ +noncomputable def metricDotMixed : B := + h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2] + +set_option maxHeartbeats 1600000 in +set_option linter.unusedSimpArgs false in +/-- **The gauge- and Lorentz-invariant terms of mass weight eight are spanned by the three + metric contractions and the square of the inner product.** The three boost sieves place + an invariant in the doubly-weight-zero span; averaging over the cyclic rotation equalises + the three transverse coefficients of each family; and the extreme boost-weight components + along each axis tie that common value to the coefficient of the time-time monomial, + collapsing each family onto its metric contraction. -/ +theorem mem_span_metric_of_invariant (x : B) (hx : ∀ g, rep g x = x) + (hLorentz : ∀ g, repLorentz g x = x) (hdim : x ∈ h.massWeightSubmodule 8) : + x ∈ (ℂ ∙ h.metricDotLeft ⊔ ℂ ∙ h.metricDotRight ⊔ ℂ ∙ h.metricDotMixed) ⊔ + ℂ ∙ (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + have hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0 := fun i => + mem_boostWeightSubmodule.2 fun t ht => by rw [hLorentz]; simp + have h8 : x ∈ h.gaugeInvariantOfMassDim 8 := + Submodule.mem_inf.2 ⟨hdim, (Representation.mem_invariants rep x).2 hx⟩ + have h1 : x ∈ (h.boostWeightZeroEight 0).piece 0 := + ((h.boostWeightZeroEight 0).toLE le_rfl).mem_piece_zero_of_mem h8 (hw 0) + have h2 : x ∈ h.dimEightPieceOne 0 := + h.dimEightWeightDecompositionLE.mem_piece_zero_of_mem h1 (hw 1) + have h3 : x ∈ h.dimEightWeightDecompositionLELE.piece 0 := + h.dimEightWeightDecompositionLELE.mem_piece_zero_of_mem h2 (hw 2) + rw [h.dimEightWeightDecompositionLELE_piece_zero_eq] at h3 + obtain ⟨y, hy, zQ, hzQ, hyz⟩ := Submodule.mem_sup.1 h3 + obtain ⟨yLR, hyLR, yM, hyM, hyLRM⟩ := Submodule.mem_sup.1 hy + obtain ⟨yL, hyL, yR, hyR, hyLR'⟩ := Submodule.mem_sup.1 hyLR + obtain ⟨aL, bL, cL, hcL⟩ := mem_span_three hyL + obtain ⟨aR, bR, cR, hcR⟩ := mem_span_three hyR + obtain ⟨aM, bM, cM, hcM⟩ := mem_span_three hyM + obtain ⟨q, hq⟩ := Submodule.mem_span_singleton.1 hzQ + have e0 : x = (aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + cL • h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + cR • h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) + bM • h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + cM • h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + rw [← hyz, ← hyLRM, ← hyLR', hcL, hcR, hcM, ← hq] + have e1 : x = (aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![] + cL • h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2] + cR • h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]) + bM • h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2] + cM • h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := + calc x = repLorentz rotationCycle x := (hLorentz _).symm + _ = _ := by + rw [e0] + simp only [map_add, map_smul, map_sub, h.repLorentz_rotationCycle_dotGaugeHiggs, + h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil, cycDir_comp_two, cycDir_comp_one, + cycDir_comp_nil, cycDir_inl, cycDir_inr, + show ((0 : Fin 3) + 1) = 1 from rfl, show ((1 : Fin 3) + 1) = 2 from rfl, + show ((2 : Fin 3) + 1) = 0 from rfl] + have e2 : x = (aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + cL • h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + cR • h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) + bM • h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + cM • h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := + calc x = repLorentz rotationCycle x := (hLorentz _).symm + _ = _ := by + rw [e1] + simp only [map_add, map_smul, map_sub, h.repLorentz_rotationCycle_dotGaugeHiggs, + h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil, cycDir_comp_two, cycDir_comp_one, + cycDir_comp_nil, cycDir_inl, cycDir_inr, + show ((0 : Fin 3) + 1) = 1 from rfl, show ((1 : Fin 3) + 1) = 2 from rfl, + show ((2 : Fin 3) + 1) = 0 from rfl] + have ekform : x = (aL • h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + ((bL + cL - aL) / 3) • (h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![])) + + (aR • h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + ((bR + cR - aR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2])) + + (aM • h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + ((bM + cM - aM) / 3) • (h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + rw [show ((aL • h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + ((bL + cL - aL) / 3) • (h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![])) + + (aR • h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + ((bR + cR - aR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2])) + + (aM • h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + ((bM + cM - aM) / 3) • (h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + = (3⁻¹ : ℂ) • (((aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + cL • h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + cR • h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) + bM • h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + cM • h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + + ((aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![] + cL • h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2] + cR • h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]) + bM • h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2] + cM • h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + + ((aL • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] - h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + bL • h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + cL • h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + + (aR • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] - h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + bR • h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + cR • h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + + (aM • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] - h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) + bM • h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + cM • h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]))) from by module, + ← e0, ← e1, ← e2] + module + have hsplit0 : x = ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 1])) + + ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 0]) + + ((bL + cL - aL) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![3, 3])) + + (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 0]) + + ((bR + cR - aR) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![3, 3])) + + (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 0]) + + ((bM + cM - aM) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by + rw [ekform] + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((0 : Fin 3) + 1) = 1 from rfl, show ((0 : Fin 3) + 2) = 2 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module + have hcomp0 := eq_zero_and_eq_zero_of_add_add_mem_boostWeightSubmodule + (a := 4) (b := -4) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![0, 0] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![0, 0] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![0, 0] (by decide))))) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![1, 1] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![1, 1] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![1, 1] (by decide))))) + (add_mem (add_mem (add_mem + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bL + cL - aL) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 0 ![3, 3] (by decide))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bR + cR - aR) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 0 ![3, 3] (by decide)))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bM + cM - aM) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 0 ![3, 3] (by decide)))))) + (Submodule.smul_mem _ q (mem_boostWeightSubmodule.2 fun t ht => by + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + simp))) + (hsplit0 ▸ hw 0) (by decide) (by decide) (by decide) + have haxis0 : ((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0]) = 0 := by + rw [show (((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0])) + = (2 : ℂ) • (((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 0 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 0 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 0 ![1, 1]))) from by + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((0 : Fin 3) + 1) = 1 from rfl, show ((0 : Fin 3) + 2) = 2 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + rw [hcomp0.1, hcomp0.2] + simp + have hsplit1 : x = ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 1])) + + ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 0]) + + ((bL + cL - aL) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![3, 3])) + + (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 0]) + + ((bR + cR - aR) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![3, 3])) + + (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 0]) + + ((bM + cM - aM) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by + rw [ekform] + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((1 : Fin 3) + 1) = 2 from rfl, show ((1 : Fin 3) + 2) = 0 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module + have hcomp1 := eq_zero_and_eq_zero_of_add_add_mem_boostWeightSubmodule + (a := 4) (b := -4) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![0, 0] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![0, 0] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![0, 0] (by decide))))) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![1, 1] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![1, 1] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![1, 1] (by decide))))) + (add_mem (add_mem (add_mem + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bL + cL - aL) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 1 ![3, 3] (by decide))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bR + cR - aR) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 1 ![3, 3] (by decide)))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bM + cM - aM) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 1 ![3, 3] (by decide)))))) + (Submodule.smul_mem _ q (mem_boostWeightSubmodule.2 fun t ht => by + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + simp))) + (hsplit1 ▸ hw 1) (by decide) (by decide) (by decide) + have haxis1 : ((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1]) = 0 := by + rw [show (((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1])) + = (2 : ℂ) • (((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 1 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 1 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 1 ![1, 1]))) from by + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((1 : Fin 3) + 1) = 2 from rfl, show ((1 : Fin 3) + 2) = 0 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + rw [hcomp1.1, hcomp1.2] + simp + have hsplit2 : x = ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1])) + + ((((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 0]) + + ((bL + cL - aL) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![3, 3])) + + (((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 0]) + + ((bR + cR - aR) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![3, 3])) + + (((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 1] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 0]) + + ((bM + cM - aM) / 3) • (IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![2, 2] + IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![3, 3])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) := by + rw [ekform] + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module + have hcomp2 := eq_zero_and_eq_zero_of_add_add_mem_boostWeightSubmodule + (a := 4) (b := -4) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![0, 0] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![0, 0] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := 4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![0, 0] (by decide))))) + (Submodule.smul_mem _ (4⁻¹ : ℂ) (add_mem (add_mem + (Submodule.smul_mem _ ((2 * aL + bL + cL) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![1, 1] (by decide))) + (Submodule.smul_mem _ ((2 * aR + bR + cR) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![1, 1] (by decide)))) + (Submodule.smul_mem _ ((2 * aM + bM + cM) / 3) (IsDerivativeCollection.lightConeDot_mem (k := -4) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![1, 1] (by decide))))) + (add_mem (add_mem (add_mem + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aL - ((bL + cL - aL) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bL + cL - aL) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![2, 0]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![2, 0]) 2 ![3, 3] (by decide))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aR - ((bR + cR - aR) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bR + cR - aR) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![0, 2]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![0, 2]) 2 ![3, 3] (by decide)))))) + (add_mem (Submodule.smul_mem _ ((4⁻¹ : ℂ) * (aM - ((bM + cM - aM) / 3))) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![0, 1] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![1, 0] (by decide)))) + (Submodule.smul_mem _ ((bM + cM - aM) / 3) (add_mem + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![2, 2] (by decide)) + (IsDerivativeCollection.lightConeDot_mem (k := 0) (h.dotSymbol ![1, 1]) + (h.isDerivativeCollection_dotSymbol.rotatesIndices ![1, 1]) 2 ![3, 3] (by decide)))))) + (Submodule.smul_mem _ q (mem_boostWeightSubmodule.2 fun t ht => by + rw [h.repLorentz_mul, h.repLorentz_dotGaugeHiggs_nil] + simp))) + (hsplit2 ▸ hw 2) (by decide) (by decide) (by decide) + have haxis2 : ((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]) = 0 := by + rw [show (((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2])) + = (2 : ℂ) • (((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![0, 0] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![0, 0] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![0, 0])) + ((4⁻¹ : ℂ) • (((2 * aL + bL + cL) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![2, 0]) 2 ![1, 1] + + ((2 * aR + bR + cR) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![0, 2]) 2 ![1, 1] + + ((2 * aM + bM + cM) / 3) • IsDerivativeCollection.lightConeDot (h.dotSymbol ![1, 1]) 2 ![1, 1]))) from by + simp only [IsDerivativeCollection.lightConeDot, + IsDerivativeCollection.lightConeDeriv_pair_zero_zero, + IsDerivativeCollection.lightConeDeriv_pair_one_one, + IsDerivativeCollection.lightConeDeriv_pair_zero_one, + IsDerivativeCollection.lightConeDeriv_pair_one_zero, + IsDerivativeCollection.lightConeDeriv_pair_two_two, + IsDerivativeCollection.lightConeDeriv_pair_three_three, + show ((2 : Fin 3) + 1) = 0 from rfl, show ((2 : Fin 3) + 2) = 1 from rfl, + LinearMap.add_apply, LinearMap.sub_apply, + h.dotSymbol_left_two, h.dotSymbol_right_two, h.dotSymbol_one_one, + Matrix.cons_val_zero, Matrix.cons_val_one, + LinearMap.toSpanSingleton_apply, one_smul] + module] + rw [hcomp2.1, hcomp2.2] + simp + have hfinal : x = ((2 * aL - bL - cL) / 4) • h.metricDotLeft + ((2 * aR - bR - cR) / 4) • h.metricDotRight + + ((2 * aM - bM - cM) / 4) • h.metricDotMixed + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![]) := by + rw [ekform, + show ((aL • h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + ((bL + cL - aL) / 3) • (h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![])) + + (aR • h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + ((bR + cR - aR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2])) + + (aM • h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + ((bM + cM - aM) / 3) • (h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2])) + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + = (((2 * aL - bL - cL) / 4) • h.metricDotLeft + ((2 * aR - bR - cR) / 4) • h.metricDotRight + + ((2 * aM - bM - cM) / 4) • h.metricDotMixed + q • (h.dotGaugeHiggs ![] ![] * h.dotGaugeHiggs ![] ![])) + + (4⁻¹ : ℂ) • ((((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 0, Sum.inr 0] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 0, Sum.inr 0]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 0] ![Sum.inr 0])) + (((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 1, Sum.inr 1] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 1, Sum.inr 1]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 1] ![Sum.inr 1])) + (((2 * aL + bL + cL) / 3) • (h.dotGaugeHiggs ![Sum.inl 0, Sum.inl 0] ![] + h.dotGaugeHiggs ![Sum.inr 2, Sum.inr 2] ![]) + + ((2 * aR + bR + cR) / 3) • (h.dotGaugeHiggs ![] ![Sum.inl 0, Sum.inl 0] + h.dotGaugeHiggs ![] ![Sum.inr 2, Sum.inr 2]) + + ((2 * aM + bM + cM) / 3) • (h.dotGaugeHiggs ![Sum.inl 0] ![Sum.inl 0] + h.dotGaugeHiggs ![Sum.inr 2] ![Sum.inr 2]))) from by + simp only [metricDotLeft, metricDotRight, metricDotMixed] + module, + haxis0, haxis1, haxis2] + simp + rw [hfinal] + exact add_mem (add_mem (add_mem + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_left + (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_left (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _)))))) + (Submodule.mem_sup_left (Submodule.mem_sup_right + (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _))))) + (Submodule.mem_sup_right (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _))) + + + +/-! + +## I. The fully invariants + +-/ + +/-! + +### I.1. Invariants of the mass dimension + +-/ + +/-- **There is no gauge- and Lorentz-invariant term of mass dimension three.** An invariant + element of the mass-weight-six sector has boost weight zero along every axis; the three + sieves — the `x`-weight decomposition, then the `y`- and `z`-boost coverings — leave no + room at weight zero. -/ +lemma gaugeInvariantOfMassDim_six_eq_boostWeightZero + (x : B) (hx : ∀ g, rep g x = x) (hLorentz : ∀ g, repLorentz g x = x) + (hdim : x ∈ h.massWeightSubmodule 6) : + x = 0 := by + have hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0 := fun i => + mem_boostWeightSubmodule.2 fun t ht => by rw [hLorentz]; simp + have h6 : x ∈ h.gaugeInvariantOfMassDim 6 := + Submodule.mem_inf.2 ⟨hdim, (Representation.mem_invariants rep x).2 hx⟩ + have h1 : x ∈ (h.boostWeightZeroSix 0).piece 0 := + ((h.boostWeightZeroSix 0).toLE le_rfl).mem_piece_zero_of_mem h6 (hw 0) + have h2 : x ∈ h.dimSixWeightDecompositionLE.piece 0 := + h.dimSixWeightDecompositionLE.mem_piece_zero_of_mem h1 (hw 1) + exact h.dimSixWeightDecompositionLELE.eq_zero_of_mem_of_zero_notMem_supp + (by simp [dimSixWeightDecompositionLELE]) h2 (hw 2) + + +/-! + +### I.2. Invariants in the full algebra + +-/ + + +end IsHiggsAlgebraValued + +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean index 938ceecf2..64baa29ab 100644 --- a/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean +++ b/Physlib/Particles/StandardModel/HiggsBoson/Basic.lean @@ -32,8 +32,9 @@ In this module we define the Higgs field and prove some basic properties. - A.3. Orthonormal basis - A.4. Generating Higgs vectors from real numbers - A.5. Action of the gauge group on `HiggsVec` - - A.5.1. Definition of the action + - A.5.1. Definition of the representation - A.5.2. Unitary nature of the action + - A.5.3. Group properties of the representation applied to vectors - A.6. The Gauge orbit of a Higgs vector - A.6.1. The rotation matrix to ofReal - A.6.2. Members of orbits @@ -160,43 +161,37 @@ The gauge group of the Standard Model acts on `HiggsVec` by matrix multiplicatio /-! -#### A.5.1. Definition of the action +#### A.5.1. Definition of the representation -/ -instance : SMul StandardModel.GaugeGroupI HiggsVec where - smul g φ := WithLp.toLp 2 <| g.toU1 ^ 3 • (g.toSU2.1 *ᵥ φ.ofLp) +/-- The representation of the gauge group `GaugeGroupI` on `HiggsVec`: the `SU(2)` + factor acts by matrix multiplication, and the `U(1)` factor by scalar + multiplication with its third power. -/ +def repGaugeGroupI : Representation ℂ GaugeGroupI HiggsVec where + toFun g := + { toFun φ := WithLp.toLp 2 <| g.toU1 ^ 3 • (g.toSU2.1 *ᵥ φ.ofLp) + map_add' φ ψ := by simp [mulVec_add, smul_add] + map_smul' c φ := by simp [mulVec_smul, smul_comm c] } + map_one' := by + ext φ + simp + map_mul' g₁ g₂ := by + ext φ + simp [Module.End.mul_apply, smul_smul, mulVec_mulVec, mul_pow, mul_comm] -lemma gaugeGroupI_smul_eq (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : - g • φ = (WithLp.toLp 2 <| g.toU1 ^ 3 • (g.toSU2.1 *ᵥ φ.ofLp)) := rfl +lemma repGaugeGroupI_apply (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI g φ = (WithLp.toLp 2 <| g.toU1 ^ 3 • (g.toSU2.1 *ᵥ φ.ofLp)) := rfl -lemma gaugeGroupI_smul_eq_U1_mul_SU2 (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : - g • φ = (WithLp.toLp 2 <| g.toSU2.1 *ᵥ (g.toU1 ^ 3 • φ.ofLp)) := by - rw [gaugeGroupI_smul_eq, ← mulVec_smul] +lemma repGaugeGroupI_apply_eq_U1_mul_SU2 (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI g φ = (WithLp.toLp 2 <| g.toSU2.1 *ᵥ (g.toU1 ^ 3 • φ.ofLp)) := by + rw [repGaugeGroupI_apply, ← mulVec_smul] -lemma gaugeGroupI_smul_eq_U1_smul_SU2 (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : - g • φ = (WithLp.toLp 2 <| (g.toU1 ^ 3 • g.toSU2.1) *ᵥ φ.ofLp) := by - rw [gaugeGroupI_smul_eq] +lemma repGaugeGroupI_apply_eq_U1_smul_SU2 (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI g φ = (WithLp.toLp 2 <| (g.toU1 ^ 3 • g.toSU2.1) *ᵥ φ.ofLp) := by + rw [repGaugeGroupI_apply] rw [Matrix.smul_mulVec] -instance : MulAction StandardModel.GaugeGroupI HiggsVec where - one_smul φ := by simp [gaugeGroupI_smul_eq] - mul_smul g₁ g₂ φ := by - simp [gaugeGroupI_smul_eq, mulVec_smul, smul_smul, mulVec_mulVec, mul_pow] - -instance : DistribMulAction StandardModel.GaugeGroupI HiggsVec where - smul_zero g := by simp [gaugeGroupI_smul_eq_U1_smul_SU2] - smul_add g φ ψ := by simp [gaugeGroupI_smul_eq_U1_smul_SU2, mulVec_add] - -TODO "Change the action of `GaugeGroupI` on `HiggsVec` to be a representation - rather than a `MulAction`." - -instance : SMulCommClass ℂ GaugeGroupI HiggsVec where - smul_comm r g φ := by simp [gaugeGroupI_smul_eq, mulVec_smul, smul_comm r] - -instance : SMulCommClass ℝ GaugeGroupI HiggsVec where - smul_comm r g φ := by simp [gaugeGroupI_smul_eq, mulVec_smul, smul_comm r] - /-! #### A.5.2. Unitary nature of the action @@ -207,18 +202,46 @@ The action of `StandardModel.GaugeGroupI` on `HiggsVec` is unitary. open InnerProductSpace @[simp] -lemma gaugeGroupI_smul_inner (g : StandardModel.GaugeGroupI) (φ ψ : HiggsVec) : - ⟪g • φ, g • ψ⟫_ℂ = ⟪φ, ψ⟫_ℂ := by - rw [gaugeGroupI_smul_eq, gaugeGroupI_smul_eq, EuclideanSpace.inner_toLp_toLp, +lemma repGaugeGroupI_inner (g : StandardModel.GaugeGroupI) (φ ψ : HiggsVec) : + ⟪repGaugeGroupI g φ, repGaugeGroupI g ψ⟫_ℂ = ⟪φ, ψ⟫_ℂ := by + rw [repGaugeGroupI_apply, repGaugeGroupI_apply, EuclideanSpace.inner_toLp_toLp, EuclideanSpace.inner_eq_star_dotProduct, Submonoid.smul_def, Submonoid.smul_def, star_smul, smul_dotProduct, dotProduct_smul, smul_smul, Unitary.mul_star_self_of_mem (g.toU1 ^ 3).2, one_smul, star_mulVec, dotProduct_comm, dotProduct_mulVec, vecMul_vecMul, ← star_eq_conjTranspose, mem_unitaryGroup_iff'.mp g.toSU2.2.1, vecMul_one, dotProduct_comm] @[simp] -lemma gaugeGroupI_smul_norm (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : - ‖g • φ‖ = ‖φ‖ := by - rw [norm_eq_sqrt_re_inner (𝕜 := ℂ), norm_eq_sqrt_re_inner (𝕜 := ℂ), gaugeGroupI_smul_inner] +lemma repGaugeGroupI_norm (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + ‖repGaugeGroupI g φ‖ = ‖φ‖ := by + rw [norm_eq_sqrt_re_inner (𝕜 := ℂ), norm_eq_sqrt_re_inner (𝕜 := ℂ), repGaugeGroupI_inner] + +/-! + +#### A.5.3. Group properties of the representation applied to vectors + +-/ + +lemma repGaugeGroupI_mul_apply (g₁ g₂ : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI (g₁ * g₂) φ = repGaugeGroupI g₁ (repGaugeGroupI g₂ φ) := by + rw [map_mul, Module.End.mul_apply] + +@[simp] +lemma repGaugeGroupI_inv_apply_apply (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI g⁻¹ (repGaugeGroupI g φ) = φ := by + rw [← repGaugeGroupI_mul_apply, inv_mul_cancel, map_one, Module.End.one_apply] + +@[simp] +lemma repGaugeGroupI_apply_inv_apply (g : StandardModel.GaugeGroupI) (φ : HiggsVec) : + repGaugeGroupI g (repGaugeGroupI g⁻¹ φ) = φ := by + rw [← repGaugeGroupI_mul_apply, mul_inv_cancel, map_one, Module.End.one_apply] + +lemma repGaugeGroupI_inv_apply_eq_iff (g : StandardModel.GaugeGroupI) (φ ψ : HiggsVec) : + repGaugeGroupI g⁻¹ φ = ψ ↔ φ = repGaugeGroupI g ψ := by + constructor + · rintro rfl + rw [repGaugeGroupI_apply_inv_apply] + · rintro rfl + rw [repGaugeGroupI_inv_apply_apply] /-! @@ -270,12 +293,12 @@ def toRealGroupElem (φ : HiggsVec) : GaugeGroupI := rw [← mul_conj, ← mul_conj] ring -lemma toRealGroupElem_smul_self (φ : HiggsVec) : - (toRealGroupElem φ) • φ = ofReal (‖φ‖ ^ 2) := by +lemma toRealGroupElem_apply_self (φ : HiggsVec) : + repGaugeGroupI (toRealGroupElem φ) φ = ofReal (‖φ‖ ^ 2) := by by_cases hφ : φ = 0 · ext i fin_cases i <;> simp [hφ, toRealGroupElem, ofReal] - rw [gaugeGroupI_smul_eq] + rw [repGaugeGroupI_apply] have h0' : (‖φ‖ ^ 2 : ℂ) = φ 0 * (starRingEnd ℂ) (φ 0) + φ 1 * (starRingEnd ℂ) (φ 1) := by rw [← ofReal_pow, ← @real_inner_self_eq_norm_sq] simp only [Fin.isValue, mul_conj, PiLp.inner_apply, Complex.inner, ofReal_re, @@ -301,16 +324,18 @@ Higgs vectors with the same norm. -/ -lemma mem_orbit_gaugeGroupI_iff (φ : HiggsVec) (ψ : HiggsVec) : - ψ ∈ MulAction.orbit GaugeGroupI φ ↔ ‖ψ‖ = ‖φ‖ := by +/-- Two Higgs vectors are in the same gauge orbit (i.e. related by `repGaugeGroupI`) + if and only if they have the same norm. -/ +lemma exists_repGaugeGroupI_eq_iff_norm_eq (φ : HiggsVec) (ψ : HiggsVec) : + (∃ g : GaugeGroupI, repGaugeGroupI g φ = ψ) ↔ ‖ψ‖ = ‖φ‖ := by constructor · rintro ⟨g, rfl⟩ simp · intro h use (toRealGroupElem ψ)⁻¹ * toRealGroupElem (φ) - simp only - rw [← smul_smul, toRealGroupElem_smul_self φ, ← h, ← toRealGroupElem_smul_self ψ] - exact inv_smul_smul _ ψ + rw [map_mul, Module.End.mul_apply, toRealGroupElem_apply_self φ, ← h, + ← toRealGroupElem_apply_self ψ, ← Module.End.mul_apply, ← map_mul, + inv_mul_cancel, map_one, Module.End.one_apply] /-! @@ -324,7 +349,7 @@ The items in this section are marked as `informal_lemma` as they are not yet for -/ /-- The Higgs boson breaks electroweak symmetry down to the electromagnetic force, i.e., the -stability group of the action of `rep` on `![0, Complex.ofReal ‖φ‖]`, for non-zero `‖φ‖`, is the +stability group of `repGaugeGroupI` on `![0, Complex.ofReal ‖φ‖]`, for non-zero `‖φ‖`, is the `SU(3) × U(1)` subgroup of `gaugeGroup := SU(3) × SU(2) × U(1)` with the embedding given by `(g, e^{i θ}) ↦ (g, diag (e ^ {3 * i θ}, e ^ {- 3 * i θ}), e^{i θ})`. -/ @@ -333,8 +358,8 @@ informal_lemma stability_group_single where tag := "6V2MD" /-- The subgroup of `gaugeGroup := SU(3) × SU(2) × U(1)` which preserves every `HiggsVec` by the -action of `StandardModel.HiggsVec.rep` is given by `SU(3) × ℤ₆` where `ℤ₆` is the subgroup of -`SU(2) × U(1)` with elements `(α^(-3) * I₂, α)` where `α` is a sixth root of unity. +action of `StandardModel.HiggsVec.repGaugeGroupI` is given by `SU(3) × ℤ₆` where `ℤ₆` is the +subgroup of `SU(2) × U(1)` with elements `(α^(-3) * I₂, α)` where `α` is a sixth root of unity. -/ informal_lemma stability_group where deps := [``HiggsVec] @@ -346,10 +371,10 @@ informal_lemma stability_group where -/ -lemma ofU1Subgroup_smul_eq_smul (g : unitary ℂ) (φ : HiggsVec) : - (StandardModel.GaugeGroupI.ofU1Subgroup g) • φ = +lemma ofU1Subgroup_repGaugeGroupI_apply (g : unitary ℂ) (φ : HiggsVec) : + repGaugeGroupI (StandardModel.GaugeGroupI.ofU1Subgroup g) φ = (WithLp.toLp 2 <| !![1, 0; 0, g.1 ^ 6] *ᵥ φ.ofLp) := by - rw [gaugeGroupI_smul_eq_U1_smul_SU2] + rw [repGaugeGroupI_apply_eq_U1_smul_SU2] simp only [GaugeGroupI.ofU1Subgroup_toU1, GaugeGroupI.ofU1Subgroup_toSU2, SubmonoidClass.coe_pow, star_pow, RCLike.star_def, smul_of, smul_cons, smul_zero, smul_empty, cons_mulVec, cons_dotProduct, zero_mul, dotProduct_of_isEmpty, add_zero, zero_add, empty_mulVec, one_mul, @@ -362,17 +387,17 @@ lemma ofU1Subgroup_smul_eq_smul (g : unitary ℂ) (φ : HiggsVec) : · show (g : ℂ) ^ 3 * (g : ℂ) ^ 3 = (g : ℂ) ^ 6 ring -lemma gaugeGroupI_smul_phase_snd (φ : HiggsVec) : +lemma repGaugeGroupI_phase_snd (φ : HiggsVec) : ∃ g : StandardModel.GaugeGroupI, - (g • φ).ofLp 1 = ‖(φ.ofLp 1)‖ ∧ - (∀ φ1 : HiggsVec, (g • φ1).ofLp 0 = φ1.ofLp 0) ∧ - (∀ a : ℝ, g • (!₂[a, 0] : HiggsVec) = (!₂[a, 0] : HiggsVec)) := by + (repGaugeGroupI g φ).ofLp 1 = ‖(φ.ofLp 1)‖ ∧ + (∀ φ1 : HiggsVec, (repGaugeGroupI g φ1).ofLp 0 = φ1.ofLp 0) ∧ + (∀ a : ℝ, repGaugeGroupI g (!₂[a, 0] : HiggsVec) = (!₂[a, 0] : HiggsVec)) := by let θ := arg (φ 1) refine ⟨StandardModel.GaugeGroupI.ofU1Subgroup ⟨Complex.exp (-I * θ / 6), by simp [Unitary.mem_iff, ← Complex.exp_conj, ← Complex.exp_add, Complex.conj_ofNat] ring_nf simp⟩, ?_, ?_, ?_⟩ - · rw [ofU1Subgroup_smul_eq_smul] + · rw [ofU1Subgroup_repGaugeGroupI_apply] simp only [Fin.isValue, neg_mul, cons_mulVec, cons_dotProduct, one_mul, zero_mul, dotProduct_of_isEmpty, add_zero, zero_add, empty_mulVec, cons_val_one, cons_val_fin_one] rw [show vecHead (vecTail φ.ofLp) = φ.ofLp 1 from rfl] @@ -382,10 +407,10 @@ lemma gaugeGroupI_smul_phase_snd (φ : HiggsVec) : ring_nf simp · intro φ - simp [ofU1Subgroup_smul_eq_smul, vecHead] + simp [ofU1Subgroup_repGaugeGroupI_apply, vecHead] · intro a ext i - fin_cases i <;> simp [ofU1Subgroup_smul_eq_smul] + fin_cases i <;> simp [ofU1Subgroup_repGaugeGroupI_apply] /-! @@ -738,7 +763,8 @@ TODO "Define the global gauge action on HiggsField." TODO "Prove `⟪φ1, φ2⟫_H` invariant under the global gauge action. (norm_map_of_mem_unitary)" TODO "Prove invariance of potential under global gauge action." -/-- The action of `gaugeTransformI` on `HiggsField` acting pointwise through `HiggsVec.rep`. -/ +/-- The action of `gaugeTransformI` on `HiggsField` acting pointwise through + `HiggsVec.repGaugeGroupI`. -/ informal_definition gaugeAction where deps := [``gaugeTransformI] tag := "6V2NP" diff --git a/Physlib/Particles/StandardModel/HiggsBoson/EffectivePotential.lean b/Physlib/Particles/StandardModel/HiggsBoson/EffectivePotential.lean index 55ac72aa5..02a3bcd3f 100644 --- a/Physlib/Particles/StandardModel/HiggsBoson/EffectivePotential.lean +++ b/Physlib/Particles/StandardModel/HiggsBoson/EffectivePotential.lean @@ -44,13 +44,13 @@ namespace EffectivePotential /-- The proposition that the general potential is invariant under the global action of the gauge group. -/ def IsInvariant (V : EffectivePotential) : Prop := - ∀ (g : GaugeGroupI), ∀ (φ : HiggsVec), V (g • φ) = V φ + ∀ (g : GaugeGroupI), ∀ (φ : HiggsVec), V (HiggsVec.repGaugeGroupI g φ) = V φ namespace IsInvariant /-- An invariant potential is equal on gauge orbits. -/ lemma eq_on_orbits {φ1 φ2 : HiggsVec} {V : EffectivePotential} (h : IsInvariant V) - (hφ : φ1 ∈ MulAction.orbit GaugeGroupI φ2) : + (hφ : ∃ g : GaugeGroupI, HiggsVec.repGaugeGroupI g φ2 = φ1) : V φ1 = V φ2 := by obtain ⟨g, rfl⟩ := hφ exact h g φ2 @@ -58,7 +58,7 @@ lemma eq_on_orbits {φ1 φ2 : HiggsVec} {V : EffectivePotential} (h : IsInvarian /-- An invariant potential is equal on Higgs vectors with identical norms. -/ lemma eq_of_norm_eq {φ1 φ2 : HiggsVec} {V : EffectivePotential} (h : IsInvariant V) (hφ : ‖φ1‖ = ‖φ2‖) : - V φ1 = V φ2 := h.eq_on_orbits <| (HiggsVec.mem_orbit_gaugeGroupI_iff φ2 φ1).mpr hφ + V φ1 = V φ2 := h.eq_on_orbits <| (HiggsVec.exists_repGaugeGroupI_eq_iff_norm_eq φ2 φ1).mpr hφ lemma factors_through_norm {V : EffectivePotential} (h : IsInvariant V) : ∃ (f : ℝ → ℝ), V = f ∘ norm := by @@ -146,13 +146,15 @@ lemma termOfMassDim_isInvariant {V : EffectivePotential} {n : ℕ} (h : HasMaxMa (m : ℕ) (hV : IsInvariant V) : IsInvariant (termOfMassDim V h m) := by intro g φ have hV (t : ℝ) := hV g (t • φ) - have h1 (t : ℝ) : ∑ m ∈ Finset.range (n + 1), t ^ m * (termOfMassDim V h m (g • φ) - + have h1 (t : ℝ) : ∑ m ∈ Finset.range (n + 1), + t ^ m * (termOfMassDim V h m (HiggsVec.repGaugeGroupI g φ) - termOfMassDim V h m φ) = 0 := by simp [mul_sub, ← apply_smul_eq_sum_termOfMassDim] - rw [smul_comm, hV, sub_eq_zero] + rw [← LinearMap.map_smul_of_tower, hV, sub_eq_zero] by_cases hmn : m ≤ n · have hp : (∑ k ∈ Finset.range (n + 1), - Polynomial.C (termOfMassDim V h k (g • φ) - termOfMassDim V h k φ) * Polynomial.X ^ k) + Polynomial.C (termOfMassDim V h k (HiggsVec.repGaugeGroupI g φ) - + termOfMassDim V h k φ) * Polynomial.X ^ k) = 0 := by apply Polynomial.funext intro x diff --git a/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean b/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean new file mode 100644 index 000000000..eab16064a --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/GaugeAlgebraAction.lean @@ -0,0 +1,545 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! +# The infinitesimal gauge action on the Higgs doublet + +## i. Overview + +The infinitesimal `(1, 2)_{3}` action of the gauge algebra on the Higgs doublet: the +weak part of the algebra element acts on the weak index and the hypercharge part scales, +both through the physicists' factor of `i`, matching the group action `u ^ 3 • U₂` +infinitesimally. The compatibility with the jet gauge action — +`GaugeAlgebra.IsInfinitesimalActionOf` — is proved at the end of this file: the +base-point Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law +and intertwine the action with the adjoint transports. The proofs work through the weak +matrix `jetGaugeMatrix` of the jet action and the all-orders matrix Leibniz rule at the +base point. + +## ii. Key results + +- `weakEnd` : the endomorphism of the Higgs doublet defined by a `2 × 2` matrix on the + weak index. +- `gaugeAlgebraAction` : the infinitesimal `(1, 2)_{3}` action of the gauge algebra. +- `isInfinitesimalActionOf` : the gauge-algebra action is the infinitesimal action + underlying the jet gauge action `repJetGaugeGroupI`. + +## iii. Table of contents + +- A. The action of the gauge algebra +- B. The infinitesimal action underlies the jet gauge action + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +namespace HiggsVec + +open Matrix MatrixGroups + +/-! + +## A. The action of the gauge algebra + +-/ + +/-- The endomorphism of the Higgs doublet defined by a `2 × 2` complex matrix acting on + the weak index. -/ +noncomputable def weakEnd (A : Matrix (Fin 2) (Fin 2) ℂ) : + HiggsVec →ₗ[ℂ] HiggsVec := + (Matrix.toLpLinAlgEquiv 2 A : Module.End ℂ HiggsVec) + +lemma weakEnd_apply (A : Matrix (Fin 2) (Fin 2) ℂ) (v : HiggsVec) : + weakEnd A v = Matrix.toLpLinAlgEquiv 2 A v := rfl + +lemma weakEnd_add (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A + B) = weakEnd A + weakEnd B := by + rw [weakEnd, weakEnd, weakEnd, map_add] + +lemma weakEnd_smul (z : ℂ) (A : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (z • A) = z • weakEnd A := by + rw [weakEnd, weakEnd, map_smul] + +lemma weakEnd_zero : weakEnd 0 = 0 := by + rw [weakEnd, map_zero] + +lemma weakEnd_neg (A : Matrix (Fin 2) (Fin 2) ℂ) : weakEnd (-A) = -weakEnd A := by + rw [show (-A : Matrix (Fin 2) (Fin 2) ℂ) = (-1 : ℂ) • A from by rw [neg_one_smul], + weakEnd_smul, neg_one_smul] + +lemma weakEnd_multiset_sum (m : Multiset (Matrix (Fin 2) (Fin 2) ℂ)) : + weakEnd m.sum = (m.map weakEnd).sum := by + induction m using Multiset.induction_on with + | empty => simp [weakEnd_zero] + | cons A t ih => rw [Multiset.sum_cons, Multiset.map_cons, Multiset.sum_cons, + weakEnd_add, ih] + +/-- The weak endomorphisms compose through matrix multiplication. -/ +lemma weakEnd_mul (A B : Matrix (Fin 2) (Fin 2) ℂ) : + weakEnd (A * B) = weakEnd A ∘ₗ weakEnd B := by + rw [weakEnd, weakEnd, weakEnd, map_mul] + rfl + +/-- The matrix of the infinitesimal `(1, 2)_{3}` action of a gauge algebra element on + the weak index: `i` times the weak part, shifted by `i` times `3` the + hypercharge. -/ +noncomputable def actionMatrix (c : GaugeAlgebra) : Matrix (Fin 2) (Fin 2) ℂ := + Complex.I • (c.toSU2Matrix + ((3 : ℂ) • c.toU1Value) • 1) + +/-- **The infinitesimal action of the gauge algebra on the Higgs doublet**: the + derivative of the `(1, 2)_{3}` action of the gauge group, real-linear in the + algebra slot and complex-linear in the value slot — the form consumed by the + covariant derivative `IsGaugeField.covDerivIter` and by + `GaugeAlgebra.IsInfinitesimalActionOf`. -/ +noncomputable def gaugeAlgebraAction : + GaugeAlgebra →ₗ[ℝ] HiggsVec →ₗ[ℂ] HiggsVec where + toFun c := weakEnd (actionMatrix c) + map_add' c₁ c₂ := by + rw [show actionMatrix (c₁ + c₂) = actionMatrix c₁ + actionMatrix c₂ from by + rw [actionMatrix, actionMatrix, actionMatrix, GaugeAlgebra.add_toSU2Matrix, + GaugeAlgebra.add_toU1Value] + module] + rw [weakEnd_add] + map_smul' r c := by + rw [show actionMatrix (r • c) = (r : ℂ) • actionMatrix c from by + rw [actionMatrix, actionMatrix, GaugeAlgebra.smul_toSU2Matrix, + GaugeAlgebra.smul_toU1Value, + show (r • c.toSU2Matrix : Matrix (Fin 2) (Fin 2) ℂ) + = (r : ℂ) • c.toSU2Matrix from by + rw [← algebraMap_smul ℂ r c.toSU2Matrix]; rfl, + show r • c.toU1Value = (r : ℂ) • c.toU1Value from by + rw [← algebraMap_smul ℂ r c.toU1Value]; rfl] + module, + weakEnd_smul] + refine LinearMap.ext fun v => ?_ + rw [RingHom.id_apply] + show (r : ℂ) • weakEnd (actionMatrix c) v = r • weakEnd (actionMatrix c) v + rw [show ((r : ℝ) : ℂ) = algebraMap ℝ ℂ r from rfl, algebraMap_smul] + +/-! + +## B. The infinitesimal action underlies the jet gauge action + +The `(1, 2)_{3}` action of the gauge algebra is the infinitesimal action underlying the +jet gauge action, in the sense of `GaugeAlgebra.IsInfinitesimalActionOf`: the base-point +Taylor coefficients of the jet action satisfy the Maurer–Cartan Leibniz law and +intertwine the action with the adjoint transports. The proofs work through the weak +matrix of the jet action and the all-orders matrix Leibniz rule at the base point. + +-/ + +section InfinitesimalAction + +open MvPowerSeries + +/-- A single formal derivative commutes with the iterated one. -/ +private lemma pderiv_foldl (μ : Fin 1 ⊕ Fin 3) (x : Multiset (Fin 1 ⊕ Fin 3)) + (f : JetRing) : + pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) f) + = x.foldl (fun h ρ => pderiv ℂ ρ h) (pderiv ℂ μ f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, ih, JetRing.pderiv_comm] + +/-- The iterated formal derivative is `ℂ`-homogeneous. -/ +private lemma foldl_pderiv_smul (x : Multiset (Fin 1 ⊕ Fin 3)) (z : ℂ) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (z • f) + = z • x.foldl (fun h ρ => pderiv ℂ ρ h) f := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, Derivation.map_smul, ih, Multiset.foldl_cons] + +/-- The jet-valued matrix of the infinitesimal `(1, 2)_{3}` action of a jet of gauge + algebra elements: the jet analogue of `actionMatrix`. -/ +noncomputable def jetActionMatrix (a : JetGaugeAlgebra) : Matrix (Fin 2) (Fin 2) JetRing := + Complex.I • (a.toSU2Matrix + ((3 : ℂ) • a.toU1Value) • 1) + +/-- The base-point Taylor coefficients of the jet action matrix are the action matrices + of the base-point Taylor coefficients. -/ +lemma jetActionMatrix_map_cc_foldl (p : Multiset (Fin 1 ⊕ Fin 3)) (a : JetGaugeAlgebra) : + ((jetActionMatrix a).map fun f => + constantCoeff (p.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p a)) := by + ext i j + rw [Matrix.map_apply, jetActionMatrix, actionMatrix, Matrix.smul_apply, + Matrix.add_apply, Matrix.smul_apply, Matrix.smul_apply, Matrix.add_apply, + Matrix.smul_apply, foldl_pderiv_smul, constantCoeff_smul, JetRing.foldl_pderiv_add, + map_add, JetGaugeAlgebra.eval_iteratedDeriv_toSU2Matrix, Matrix.map_apply] + congr 2 + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq, smul_eq_mul, mul_one, smul_eq_mul, + mul_one, foldl_pderiv_smul, constantCoeff_smul, + JetGaugeAlgebra.eval_iteratedDeriv_toU1Value] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + JetRing.foldl_pderiv_zero, map_zero] + +/-- The entrywise formal derivative on the weak coordinates, as a `ℂ`-linear map. -/ +private noncomputable def pderivWeak (μ : Fin 1 ⊕ Fin 3) : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace JetRing (Fin 2) where + toFun v := WithLp.toLp 2 fun i => pderiv ℂ μ (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact Derivation.map_smul _ _ _ + +/-- The entrywise iterated formal derivative on the weak coordinates. -/ +private noncomputable def foldWeak (x : Multiset (Fin 1 ⊕ Fin 3)) : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace JetRing (Fin 2) where + toFun v := WithLp.toLp 2 fun i => x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact JetRing.foldl_pderiv_add x _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact foldl_pderiv_smul x z _ + +/-- The entrywise base-point evaluation on the weak coordinates. -/ +private noncomputable def ccWeak : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace ℂ (Fin 2) where + toFun v := WithLp.toLp 2 fun i => constantCoeff (v.ofLp i) + map_add' v w := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact map_add _ _ _ + map_smul' z v := by + refine WithLp.ofLp_injective 2 ?_ + funext i + exact constantCoeff_smul _ _ + +private lemma pderivWeak_comp_foldWeak (μ : Fin 1 ⊕ Fin 3) + (x : Multiset (Fin 1 ⊕ Fin 3)) : + pderivWeak μ ∘ₗ foldWeak x = foldWeak (μ ::ₘ x) := by + refine LinearMap.ext fun v => ?_ + refine WithLp.ofLp_injective 2 ?_ + funext i + show pderiv ℂ μ (x.foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i)) + = (μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) (v.ofLp i) + rw [Multiset.foldl_cons, pderiv_foldl] + +/-- The identification of Higgs-doublet jets intertwines the formal derivative with the + entrywise derivative on the weak coordinates. -/ +private lemma jetValLinEquiv_jetDeriv (μ : Fin 1 ⊕ Fin 3) + (z : JetRing ⊗[ℂ] HiggsVec) : + jetValLinEquiv (StandardModel.jetDeriv μ z) + = pderivWeak μ (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [map_add, map_add, ha, hb, map_add, map_add] + | tmul f v => + rw [StandardModel.jetDeriv_tmul, jetValLinEquiv_tmul, jetValLinEquiv_tmul] + refine WithLp.ofLp_injective 2 ?_ + funext i + exact (Derivation.map_smul (pderiv ℂ μ) (v.ofLp i) f).symm + +/-- The identification of Higgs-doublet jets intertwines the iterated formal derivative + with the entrywise iterated derivative on the weak coordinates. -/ +private lemma jetValLinEquiv_jetIteratedDeriv (x : Multiset (Fin 1 ⊕ Fin 3)) + (z : JetRing ⊗[ℂ] HiggsVec) : + jetValLinEquiv (StandardModel.jetIteratedDeriv x z) + = foldWeak x (jetValLinEquiv z) := by + induction x using Multiset.induction_on with + | empty => + rw [StandardModel.jetIteratedDeriv_zero, LinearMap.id_apply, + show foldWeak 0 = LinearMap.id from LinearMap.ext fun v => + WithLp.ofLp_injective 2 rfl, + LinearMap.id_apply] + | cons μ t ih => + rw [StandardModel.jetIteratedDeriv_cons, LinearMap.comp_apply, + jetValLinEquiv_jetDeriv, ih, ← LinearMap.comp_apply, pderivWeak_comp_foldWeak] + +/-- The base-point evaluation of a Higgs-doublet jet through the weak coordinates. -/ +private lemma jetEval_eq (z : JetRing ⊗[ℂ] HiggsVec) : + StandardModel.jetEval z = ccWeak (jetValLinEquiv z) := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [map_add, map_add, map_add, ha, hb] + | tmul f v => + rw [StandardModel.jetEval_tmul, jetValLinEquiv_tmul] + refine WithLp.ofLp_injective 2 ?_ + funext i + show (constantCoeff f • v).ofLp i = constantCoeff (v.ofLp i • f) + simp [constantCoeff_smul, mul_comm] + +set_option maxHeartbeats 1000000 in +/-- **The derivative identity** for the weak matrix of the jet gauge action: the + formal derivative of the weak matrix is minus the jet action matrix of the + Maurer–Cartan form times the weak matrix. -/ +lemma jetGaugeMatrix_map_pderiv (U : JetGaugeGroupI) (μ : Fin 1 ⊕ Fin 3) : + (jetGaugeMatrix U).map (fun f => pderiv ℂ μ f) + = -(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U) := by + have hjet : jetGaugeMatrix U + = (((U.2.2 : unitary JetRing) : JetRing) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) := rfl + have hleib : ∀ f g : JetRing, + pderiv ℂ μ (f * g) = pderiv ℂ μ f * g + f * pderiv ℂ μ g := fun f g => by + rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul, add_comm, mul_comm g] + have huu : ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Unitary.mul_star_self_of_mem (U.2.2 : unitary JetRing).2 + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + have hm₂U₂ : (maurerCartanForm U μ).toSU2Matrix * U.2.1.1 + = Complex.I • U.2.1.1.map (pderiv ℂ μ) := by + rw [maurerCartanForm_toSU2Matrix, Matrix.smul_mul, Matrix.mul_assoc, hU₂u, + Matrix.mul_one] + have hiC : (algebraMap ℂ JetRing) Complex.I * (algebraMap ℂ JetRing) Complex.I + = -1 := by + rw [← map_mul, Complex.I_mul_I, map_neg, map_one] + have hmap : (((((U.2.2 : unitary JetRing) : JetRing)) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing)).map (fun f => pderiv ℂ μ f) + = (pderiv ℂ μ (((U.2.2 : unitary JetRing) : JetRing) ^ 3)) • U.2.1.1 + + ((((U.2.2 : unitary JetRing) : JetRing)) ^ 3) + • (U.2.1.1.map (pderiv ℂ μ)) := by + refine Matrix.ext fun i j => ?_ + simp only [Matrix.map_apply, Matrix.smul_apply, Matrix.add_apply, smul_eq_mul] + exact hleib _ _ + rw [hjet, jetActionMatrix, hmap, Matrix.smul_mul, Matrix.add_mul, + Matrix.mul_smul, hm₂U₂, Matrix.smul_mul, Matrix.one_mul, + smul_comm ((((U.2.2 : unitary JetRing) : JetRing)) ^ 3) Complex.I, + smul_add, smul_smul Complex.I Complex.I, Complex.I_mul_I, neg_one_smul, + ← smul_assoc, neg_add, neg_neg, ← neg_smul, smul_smul, + add_comm (pderiv ℂ μ (((U.2.2 : unitary JetRing) : JetRing) ^ 3) • U.2.1.1) + ((((U.2.2 : unitary JetRing) : JetRing) ^ 3) • U.2.1.1.map (pderiv ℂ μ))] + congr 1 + congr 1 + rw [maurerCartanForm_toU1Value, + show ((U.2.2 : unitary JetRing) : JetRing) ^ 3 + = ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) from by ring, + hleib, hleib, Algebra.smul_def, Algebra.smul_def, Algebra.smul_def, + map_ofNat] + linear_combination (3 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * star ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing)) * hiC + - (3 * pderiv ℂ μ ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing) + * ((U.2.2 : unitary JetRing) : JetRing)) * huu + +/-- **The equivariance identity** for the weak matrix of the jet gauge action: the + weak matrix intertwines the constant jet action matrix with its adjoint + transform. -/ +lemma jetGaugeMatrix_mul_jetActionMatrix (U : JetGaugeGroupI) (c : GaugeAlgebra) : + jetGaugeMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = jetActionMatrix (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c)) + * jetGaugeMatrix U := by + have hjet : jetGaugeMatrix U + = (((U.2.2 : unitary JetRing) : JetRing) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) := rfl + have hU₂u : star U.2.1.1 * U.2.1.1 = 1 := + Matrix.mem_unitaryGroup_iff'.mp (Matrix.mem_specialUnitaryGroup_iff.mp U.2.1.2).1 + rw [hjet, jetActionMatrix, jetActionMatrix, + JetGaugeAlgebra.adjointMap_toSU2Matrix, JetGaugeAlgebra.adjointMap_toU1Value] + conv_lhs => rw [Matrix.mul_smul, Matrix.smul_mul, Matrix.mul_add, Matrix.mul_smul, + Matrix.mul_one] + conv_rhs => rw [Matrix.smul_mul, Matrix.add_mul, Matrix.mul_smul, + Matrix.smul_mul, Matrix.one_mul, Matrix.mul_assoc, hU₂u, Matrix.mul_one] + rw [smul_add, smul_comm ((((U.2.2 : unitary JetRing) : JetRing)) ^ 3) + ((3 : ℂ) • (JetGaugeAlgebra.ofConstant c).toU1Value)] + +/-- The iterated formal derivative of a negation. -/ +private lemma foldl_pderiv_neg (x : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + x.foldl (fun h ρ => pderiv ℂ ρ h) (-f) + = -(x.foldl (fun h ρ => pderiv ℂ ρ h) f) := by + induction x using Multiset.induction_on generalizing f with + | empty => rfl + | cons ν t ih => rw [Multiset.foldl_cons, map_neg, ih, Multiset.foldl_cons] + +set_option maxHeartbeats 1000000 in +/-- **The base-point Taylor coefficients of the jet gauge action** on the Higgs + doublet are the weak endomorphisms of the base-point Taylor coefficients of the + weak matrix. -/ +lemma repCoeff_eq (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + IsGaugeField.repCoeff repJetGaugeGroupI U x + = weakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) := by + refine LinearMap.ext fun v => ?_ + rw [show IsGaugeField.repCoeff repJetGaugeGroupI U x v + = StandardModel.jetEval (StandardModel.jetIteratedDeriv x + (repJetGaugeGroupI U (StandardModel.jetOfConstant v))) from rfl, + jetEval_eq, jetValLinEquiv_jetIteratedDeriv, repJetGaugeGroupI_apply, + LinearEquiv.apply_symm_apply, StandardModel.jetOfConstant_apply, + jetValLinEquiv_tmul] + refine WithLp.ofLp_injective 2 ?_ + funext j + show constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) + (((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun i => v.ofLp i • (1 : JetRing))).ofLp j)) + = ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) v).ofLp j + rw [show ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)) + (WithLp.toLp 2 fun i => v.ofLp i • (1 : JetRing))).ofLp j + = ∑ k, jetGaugeMatrix U j k * (v.ofLp k • (1 : JetRing)) from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + show ((Matrix.toLpLinAlgEquiv 2 ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) v).ofLp j + = ∑ k, constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) (jetGaugeMatrix U j k)) + * v.ofLp k from by + simp [Matrix.mulVec_eq_sum, Finset.sum_apply, mul_comm], + JetRing.foldl_pderiv_sum, map_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [mul_smul_comm, mul_one, foldl_pderiv_smul, constantCoeff_smul, smul_eq_mul, + mul_comm] + + +/-- The weak endomorphism of the identity matrix is the identity. -/ +lemma weakEnd_one : weakEnd 1 = LinearMap.id := by + rw [weakEnd, map_one, Module.End.one_eq_id] + +/-- At the base point, a gauge jet with trivial value acts trivially: the zeroth + Taylor coefficient of the jet gauge action is the identity. -/ +lemma repCoeff_zero_of_eval_eq_one {U : JetGaugeGroupI} (hU : U.eval = 1) : + IsGaugeField.repCoeff repJetGaugeGroupI U 0 = LinearMap.id := by + have h2 : (constantCoeff : JetRing →+* ℂ).mapMatrix + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + = 1 := Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.1) hU) + have hu : constantCoeff ((U.2.2 : unitary JetRing) : JetRing) = 1 := + Subtype.ext_iff.mp (congrArg (fun p : GaugeGroupI => p.2.2) hU) + have hM : ((jetGaugeMatrix U).map fun f => + constantCoeff ((0 : Multiset (Fin 1 ⊕ Fin 3)).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = 1 := by + ext i j + rw [Matrix.map_apply, Multiset.foldl_zero, jetGaugeMatrix, Matrix.smul_apply, + smul_eq_mul, map_mul, map_pow, hu, one_pow, one_mul] + exact Matrix.ext_iff.mpr h2 i j + rw [repCoeff_eq, hM, weakEnd_one] + +set_option maxHeartbeats 1000000 in +/-- **The `(1, 2)_{3}` action of the gauge algebra is the infinitesimal action + underlying the jet gauge action on the Higgs doublet**: its base-point Taylor + coefficients obey the Maurer–Cartan Leibniz law and intertwine the action with the + adjoint transports. -/ +theorem isInfinitesimalActionOf : + GaugeAlgebra.IsInfinitesimalActionOf gaugeAlgebraAction repJetGaugeGroupI := by + constructor + · intro U μ x + have hMcons : ((jetGaugeMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -((x.antidiagonal.map fun p => + actionMatrix (JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (maurerCartanForm U μ))) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum) := by + rw [show ((jetGaugeMatrix U).map fun f => + constantCoeff ((μ ::ₘ x).foldl (fun h ρ => pderiv ℂ ρ h) f)) + = (((jetGaugeMatrix U).map fun f => pderiv ℂ μ f).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.map_apply, Matrix.map_apply, + Multiset.foldl_cons], + jetGaugeMatrix_map_pderiv, + show ((-(jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = -(((jetActionMatrix (maurerCartanForm U μ) * jetGaugeMatrix U)).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) from + Matrix.ext fun i j => by + rw [Matrix.map_apply, Matrix.neg_apply, Matrix.neg_apply, + Matrix.map_apply, foldl_pderiv_neg, map_neg], + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => by rw [jetActionMatrix_map_cc_foldl])) + rw [repCoeff_eq, hMcons, weakEnd_neg, weakEnd_multiset_sum, Multiset.map_map] + refine congrArg Neg.neg (congrArg Multiset.sum (Multiset.map_congr rfl + fun p hp => ?_)) + rw [Function.comp_apply, weakEnd_mul, repCoeff_eq] + rfl + · intro U x c + have hCsmul : ∀ z w : ℂ, (z • (C w : JetRing)) = C (z * w) := fun z w => by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + Algebra.algebraMap_self_apply, ← map_mul] + have hconst : jetActionMatrix (JetGaugeAlgebra.ofConstant c) + = (actionMatrix c).map (C : ℂ → JetRing) := by + refine Matrix.ext fun i j => ?_ + rw [jetActionMatrix, actionMatrix, JetGaugeAlgebra.ofConstant_toSU2Matrix, + JetGaugeAlgebra.ofConstant_toU1Value, Matrix.map_apply, Matrix.smul_apply, + Matrix.add_apply, Matrix.map_apply, Matrix.smul_apply, Matrix.smul_apply, + Matrix.add_apply, Matrix.smul_apply] + by_cases hij : i = j + · subst hij + rw [Matrix.one_apply_eq, Matrix.one_apply_eq] + simp only [smul_eq_mul, mul_one] + rw [hCsmul, ← map_add, hCsmul] + · rw [Matrix.one_apply_ne hij, Matrix.one_apply_ne hij, smul_zero, smul_zero, + add_zero, add_zero, hCsmul] + exact congrArg C (by ring) + have hcollapse : ∀ (m : Multiset (Fin 1 ⊕ Fin 3)), + (((actionMatrix c).map (C : ℂ → JetRing)).map fun f => + constantCoeff (m.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = if m = 0 then actionMatrix c else 0 := by + intro m + rcases eq_or_ne m 0 with rfl | hm + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, constantCoeff_C] + · refine Matrix.ext fun i j => ?_ + simp [Matrix.map_apply, JetRing.foldl_pderiv_C_of_ne_zero hm, hm] + have hMact : ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) * actionMatrix c + = (x.antidiagonal.map fun p => + actionMatrix (IsGaugeField.adjointCoeff U p.1 c) + * ((jetGaugeMatrix U).map fun f => + constantCoeff (p.2.foldl (fun h ρ => pderiv ℂ ρ h) f))).sum := by + have h1 : ((jetGaugeMatrix U * jetActionMatrix (JetGaugeAlgebra.ofConstant c)).map + fun f => constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + = ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c := by + rw [hconst, matrix_constantCoeff_foldl_pderiv_mul, + Multiset.map_congr rfl (fun p hp => by rw [hcollapse p.2]), + Multiset.sum_antidiagonal_eq_of_snd_ne_zero x + (fun p => ((jetGaugeMatrix U).map fun f => + constantCoeff (p.1.foldl (fun h ρ => pderiv ℂ ρ h) f)) * + (if p.2 = 0 then actionMatrix c else 0)) + (fun p hp => by rw [if_neg hp, Matrix.mul_zero]), + if_pos rfl] + rw [← h1, jetGaugeMatrix_mul_jetActionMatrix, + matrix_constantCoeff_foldl_pderiv_mul] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + rw [jetActionMatrix_map_cc_foldl, + show JetGaugeAlgebra.eval (JetGaugeAlgebra.iteratedDeriv p.1 + (JetGaugeAlgebra.adjointMap U (JetGaugeAlgebra.ofConstant c))) + = IsGaugeField.adjointCoeff U p.1 c from rfl]) + rw [repCoeff_eq, + show (weakEnd ((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f))) + ∘ₗ gaugeAlgebraAction c + = weakEnd (((jetGaugeMatrix U).map fun f => + constantCoeff (x.foldl (fun h ρ => pderiv ℂ ρ h) f)) + * actionMatrix c) from by + rw [weakEnd_mul]; rfl, + hMact, weakEnd_multiset_sum, Multiset.map_map] + refine congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => ?_) + rw [Function.comp_apply, weakEnd_mul, repCoeff_eq] + rfl + +end InfinitesimalAction + +end HiggsVec + +end StandardModel diff --git a/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Basic.lean new file mode 100644 index 000000000..9c9f2b713 --- /dev/null +++ b/Physlib/Particles/StandardModel/HiggsBoson/JetAlgebra/Basic.lean @@ -0,0 +1,321 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.HiggsBoson.Basic +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +/-! +# The jet algebra of the Higgs field + +## i. Overview + +The Higgs field is a bosonic matter field valued in `HiggsVec`, so its jet algebra is the +bosonic algebra `BosonicAlgebra HiggsVec`: the symmetric algebra on the component +functions `∂_s H_α` and `∂_s H̄_α`, commuting as bosons do. + +The file first equips the jets `JetRing ⊗[ℂ] HiggsVec` of the Higgs field with the action +of the jet gauge group, following the same pattern as the fermion species (see +`Physlib.Particles.StandardModel.Fermions.DownSinglet`): the `SU(2)` power-series matrix, +scaled by the hypercharge power series `u ^ 3`, acts `JetRing`-linearly through the +identification `JetRing ⊗[ℂ] HiggsVec ≃ EuclideanSpace JetRing (Fin 2)`. Everything the +generic bosonic algebra provides — the total derivative, the Lorentz action (trivial: the +Higgs is a Lorentz scalar), the jet gauge action, and the mass-weight scaling at the Higgs +mass weight `2` — is then instantiated. + +## ii. Key results + +- `HiggsVec.jetValLinEquiv` : the jets of the Higgs field as a `JetRing`-valued doublet. +- `HiggsVec.repJetGaugeGroupI` : the jet gauge action on the jets of the Higgs field. +- `HiggsVec.repJetGaugeGroupI_smul` : the action is fibrewise. +- `HiggsVec.repJetGaugeGroupI_ofConstant` : constant jets act by the global gauge action. +- `HiggsJetAlgebra` : the jet algebra of the Higgs field. +- `HiggsJetAlgebra.ofHiggs`, `HiggsJetAlgebra.ofConjHiggs` : the component functions. +- `HiggsJetAlgebra.repLorentzGroup`, `HiggsJetAlgebra.repJetGaugeGroupI` : the actions. +- `HiggsJetAlgebra.massWeightScale` : the mass-dimension scaling at mass weight `2`. + +## iii. Table of contents + +- A. The jet gauge action on the jets of the Higgs field + - A.1. The jets of the Higgs field + - A.2. The action of the jet gauge group + - A.3. Fibrewise linearity + - A.4. Constant jets act by the global gauge action +- B. The jet algebra of the Higgs field + - B.1. The component functions + - B.2. The Lorentz action + - B.3. The jet gauge action + - B.4. The mass-dimension scaling + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix + +namespace HiggsVec + +/-! + +## A. The jet gauge action on the jets of the Higgs field + +-/ + +/-! + +### A.1. The jets of the Higgs field + +-/ + +/-- Absorbs the jet ring into the weak index: a jet of the Higgs field is the same thing +as a `JetRing`-valued weak doublet, + + `JetRing ⊗[ℂ] HiggsVec ≃ EuclideanSpace JetRing (Fin 2)`. + +-/ +noncomputable def jetValLinEquiv : + JetRing ⊗[ℂ] HiggsVec ≃ₗ[ℂ] EuclideanSpace JetRing (Fin 2) := + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) + (WithLp.linearEquiv 2 ℂ (Fin 2 → ℂ))).trans <| + ((TensorProduct.piScalarRight ℂ JetRing JetRing (Fin 2)).trans + (WithLp.linearEquiv 2 JetRing (Fin 2 → JetRing)).symm).restrictScalars ℂ + +lemma jetValLinEquiv_tmul (f : JetRing) (v : HiggsVec) : + jetValLinEquiv (f ⊗ₜ[ℂ] v) = WithLp.toLp 2 fun i => v.ofLp i • f := rfl + +/-- The identification of the jets of the Higgs field is `JetRing`-linear: multiplying a + jet by a scalar jet multiplies each of its weak components. -/ +lemma jetValLinEquiv_smul (χ : JetRing) (z : JetRing ⊗[ℂ] HiggsVec) : + jetValLinEquiv (χ • z) = χ • jetValLinEquiv z := by + induction z using TensorProduct.induction_on with + | zero => simp + | add a b ha hb => rw [smul_add, map_add, ha, hb, map_add, smul_add] + | tmul f v => + rw [TensorProduct.smul_tmul', smul_eq_mul, jetValLinEquiv_tmul, jetValLinEquiv_tmul] + refine WithLp.ofLp_injective 2 ?_ + funext i + show v.ofLp i • (χ * f) = χ * (v.ofLp i • f) + rw [Algebra.mul_smul_comm] + +lemma jetValLinEquiv_symm_smul (χ : JetRing) (y : EuclideanSpace JetRing (Fin 2)) : + jetValLinEquiv.symm (χ • y) = χ • jetValLinEquiv.symm y := by + apply jetValLinEquiv.injective + rw [LinearEquiv.apply_symm_apply, jetValLinEquiv_smul, LinearEquiv.apply_symm_apply] + +/-! + +### A.2. The action of the jet gauge group + +-/ + +/-- The matrix of jets through which a jet of gauge transformations acts on the Higgs + doublet: the `SU(2)` power-series matrix scaled by the hypercharge power series + `u ^ 3`. -/ +noncomputable def jetGaugeMatrix (U : JetGaugeGroupI) : Matrix (Fin 2) (Fin 2) JetRing := + (((U.2.2 : unitary JetRing) : JetRing) ^ 3) • + ((U.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + +lemma jetGaugeMatrix_one : jetGaugeMatrix 1 = 1 := by + simp [jetGaugeMatrix] + +lemma jetGaugeMatrix_mul (U₁ U₂ : JetGaugeGroupI) : + jetGaugeMatrix (U₁ * U₂) = jetGaugeMatrix U₁ * jetGaugeMatrix U₂ := by + rw [jetGaugeMatrix, jetGaugeMatrix, jetGaugeMatrix, + show (((U₁ * U₂).2.2 : unitary JetRing) : JetRing) = + ((U₁.2.2 : unitary JetRing) : JetRing) * ((U₂.2.2 : unitary JetRing) : JetRing) from rfl, + show (((U₁ * U₂).2.1 : specialUnitaryGroup (Fin 2) JetRing) : + Matrix (Fin 2) (Fin 2) JetRing) = + ((U₁.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) * + ((U₂.2.1 : specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) + from rfl, + mul_pow, Matrix.smul_mul, Matrix.mul_smul, smul_smul] + +/-- The `2_{3}` action of the jet gauge group on the jets of the Higgs field. Through +`jetValLinEquiv` the weak matrix of the gauge jet, carrying the `3` hypercharge phase +`u ^ 3`, acts `JetRing`-linearly by matrix-vector multiplication. -/ +noncomputable def repJetGaugeGroupI : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] HiggsVec) where + toFun U := + jetValLinEquiv.symm.toLinearMap ∘ₗ + ((Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U)).restrictScalars ℂ : + EuclideanSpace JetRing (Fin 2) →ₗ[ℂ] EuclideanSpace JetRing (Fin 2)) ∘ₗ + jetValLinEquiv.toLinearMap + map_one' := by + have hres : (1 : Module.End JetRing (EuclideanSpace JetRing (Fin 2))).restrictScalars ℂ + = 1 := rfl + rw [jetGaugeMatrix_one, map_one, hres] + ext z + simp + map_mul' U₁ U₂ := by + have hres : ∀ f g : Module.End JetRing (EuclideanSpace JetRing (Fin 2)), + (f * g).restrictScalars ℂ = f.restrictScalars ℂ * g.restrictScalars ℂ := + fun _ _ => rfl + rw [jetGaugeMatrix_mul, map_mul, hres] + ext z + simp + +lemma repJetGaugeGroupI_apply (U : JetGaugeGroupI) (z : JetRing ⊗[ℂ] HiggsVec) : + repJetGaugeGroupI U z = + jetValLinEquiv.symm + (Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix U) (jetValLinEquiv z)) := rfl + +/-! + +### A.3. Fibrewise linearity + +-/ + +/-- **The jet gauge action on the jets of the Higgs field is fibrewise**: it commutes + with multiplication by scalar jets, acting on the values of the field over the identity + on spacetime. This is the hypothesis under which the action lifts to the bosonic + algebra. -/ +lemma repJetGaugeGroupI_smul (U : JetGaugeGroupI) (χ : JetRing) + (z : JetRing ⊗[ℂ] HiggsVec) : + repJetGaugeGroupI U (χ • z) = χ • repJetGaugeGroupI U z := by + rw [repJetGaugeGroupI_apply, repJetGaugeGroupI_apply, jetValLinEquiv_smul, map_smul, + jetValLinEquiv_symm_smul] + +/-! + +### A.4. Constant jets act by the global gauge action + +-/ + +/-- On jets of constant gauge transformations the jet action reduces to the global gauge +action on the fibre: the action `HiggsVec.repGaugeGroupI` on the Higgs factor, and the +trivial action on the jet ring. -/ +lemma repJetGaugeGroupI_ofConstant (g : GaugeGroupI) : + repJetGaugeGroupI (JetGaugeGroupI.ofConstant g) = + TensorProduct.map LinearMap.id (repGaugeGroupI g) := by + ext f v + have hu : (((JetGaugeGroupI.ofConstant g).2.2 : unitary JetRing) : JetRing) + = MvPowerSeries.C ((g.toU1.1 : ℂ)) := rfl + have hM : ∀ i j, (((JetGaugeGroupI.ofConstant g).2.1 : + specialUnitaryGroup (Fin 2) JetRing) : Matrix (Fin 2) (Fin 2) JetRing) i j + = MvPowerSeries.C (g.toSU2.1 i j) := fun _ _ => rfl + simp only [TensorProduct.AlgebraTensorModule.curry_apply, TensorProduct.curry_apply, + LinearMap.restrictScalars_apply, repJetGaugeGroupI_apply, TensorProduct.map_tmul, + LinearMap.id_apply] + apply jetValLinEquiv.injective + rw [LinearEquiv.apply_symm_apply, jetValLinEquiv_tmul, jetValLinEquiv_tmul] + have halg : (Matrix.toLpLinAlgEquiv 2 (jetGaugeMatrix (JetGaugeGroupI.ofConstant g)) : + Module.End JetRing (EuclideanSpace JetRing (Fin 2))) + = Matrix.toLpLin 2 2 (jetGaugeMatrix (JetGaugeGroupI.ofConstant g)) := rfl + rw [halg] + refine WithLp.ofLp_injective 2 ?_ + funext i + simp only [Matrix.toLpLin_toLp, Matrix.toLin'_apply, Matrix.mulVec_apply_eq_sum] + rw [show (repGaugeGroupI g v).ofLp = g.toU1 ^ 3 • (g.toSU2.1 *ᵥ v.ofLp) from rfl] + simp only [jetGaugeMatrix, Matrix.smul_apply, hu, hM, ← map_pow, smul_eq_mul, ← map_mul, + Pi.smul_apply, Matrix.mulVec_apply_eq_sum, Submonoid.smul_def, smul_eq_mul, + Finset.mul_sum, Finset.sum_smul, smul_smul] + refine Finset.sum_congr rfl fun j _ => ?_ + rw [mul_smul_comm, + show (MvPowerSeries.C (((GaugeGroupI.toU1 g : unitary ℂ) : ℂ) ^ 3 + * (g.toSU2.1 i j)) : JetRing) * f + = (((GaugeGroupI.toU1 g : unitary ℂ) : ℂ) ^ 3 * (g.toSU2.1 i j)) • f from by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, Algebra.algebraMap_self_apply], + smul_smul] + congr 1 + rw [show ((GaugeGroupI.toU1 (g ^ 3) : unitary ℂ) : ℂ) + = ((GaugeGroupI.toU1 g : unitary ℂ) : ℂ) ^ 3 from rfl] + ring + +end HiggsVec + +/-! + +## B. The jet algebra of the Higgs field + +-/ + +/-- **The jet algebra of the Higgs field**: the bosonic algebra of the `HiggsVec`-valued + Higgs field. Its generators are the component functions `∂_s H_α` and `∂_s H̄_α`, and + they commute — the Higgs is a boson. -/ +abbrev HiggsJetAlgebra : Type := BosonicAlgebra HiggsVec + +namespace HiggsJetAlgebra + +/-! + +### B.1. The component functions + +-/ + +/-- The component functions of the Higgs field inside its jet algebra. -/ +noncomputable def ofHiggs : Module.Dual ℂ HiggsVec →ₗ[ℂ] HiggsJetAlgebra := + BosonicAlgebra.ofField + +/-- The conjugate component functions of the Higgs field inside its jet algebra. -/ +noncomputable def ofConjHiggs : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] HiggsJetAlgebra := + BosonicAlgebra.ofConjField + +/-! + +### B.2. The Lorentz action + +-/ + +open Matrix MatrixGroups in +/-- The Lorentz action on the jet algebra of the Higgs field: the Higgs is a Lorentz + scalar, so the Lorentz group acts on the component functions only through their + derivative labels. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) HiggsJetAlgebra := + BosonicAlgebra.repLorentzGroup (Representation.trivial ℂ SL(2,ℂ) HiggsVec) + +/-! + +### B.3. The jet gauge action + +-/ + +/-- The jet gauge action on the jet algebra of the Higgs field, lifted from the fibrewise + action on its jets. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI HiggsJetAlgebra := + BosonicAlgebra.repJetGaugeGroupI HiggsVec.repJetGaugeGroupI + HiggsVec.repJetGaugeGroupI_smul + +/-- The action of the constant — global — gauge transformations on the jet algebra of the + Higgs field. -/ +noncomputable def repGaugeGroupI : Representation ℂ GaugeGroupI HiggsJetAlgebra := + BosonicAlgebra.repGaugeGroupI HiggsVec.repJetGaugeGroupI + HiggsVec.repJetGaugeGroupI_smul + +/-! + +### B.4. The mass-dimension scaling + +-/ + +/-- The mass-dimension scaling on the jet algebra of the Higgs field: the Higgs has mass + dimension one, that is mass weight two, and each derivative adds mass weight two. -/ +noncomputable def massWeightScale (c : ℂ) : HiggsJetAlgebra →ₐ[ℂ] HiggsJetAlgebra := + BosonicAlgebra.massWeightScale 2 c + +/-- The Higgs field carries mass weight two — mass dimension one. -/ +@[simp] +lemma massWeightScale_ofHiggs (c : ℂ) (φ : Module.Dual ℂ HiggsVec) : + massWeightScale c (ofHiggs φ) = c ^ 2 • ofHiggs φ := + BosonicAlgebra.massWeightScale_ofField 2 c φ + +/-- A derivative of the Higgs field adds mass weight two. -/ +lemma massWeightScale_jetDeriv (c : ℂ) (μ : Fin 1 ⊕ Fin 3) (x : HiggsJetAlgebra) : + massWeightScale c (BosonicAlgebra.jetDeriv μ x) + = c ^ 2 • BosonicAlgebra.jetDeriv μ (massWeightScale c x) := + BosonicAlgebra.massWeightScale_jetDeriv 2 c μ x + +end HiggsJetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/Basic.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/Basic.lean new file mode 100644 index 000000000..9571d567d --- /dev/null +++ b/Physlib/Particles/StandardModel/IsCovStandardModel/Basic.lean @@ -0,0 +1,712 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Symmeterized +public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction +/-! +# The algebra valued Standard model + +The basic idea here is to just reduce things +down to the covariant version. +In the covariant version we will do the work with +the invariants. + +This file carries the structure `IsCovStandardModel` itself — the covariant fields +with their gauge, Lorentz, mass-weight and commutation properties — together with the +algebra they generate. The covariant generators of that algebra are in +`IsCovStandardModel.Generators`, and the mass-weight grading in +`IsCovStandardModel.MassWeight`. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +structure IsCovStandardModel (B : Type) [Ring B] [Algebra ℂ B] + -- The representations + (repGauge : Representation ℂ GaugeGroupI B) (repLorentz : Representation ℂ SL(2,ℂ) B) + -- The mass weights + (massWeightPoly : B →ₐ[ℂ] Polynomial B) + -- The Higgs fields + covariant derivatives + (H : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B) + (barH : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B) + -- The field strength + covariant derivatives derivatives + (F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + -- Three families of down-type quarks + derivatives + conjugates + (d : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B) + (bard : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B) + -- Three families of up-type quarks + derivatives + conjugates + (u : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B) + (baru :{n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B) + -- Three families of quark doublets + derivatives + conjugates + (Q : {n : ℕ} →Fin 3 → (Fin n → Fin 1 ⊕ Fin 3)→ Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B) + (barQ : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B) + -- Three families of lepton doublets + derivatives + conjugates + (L : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B) + (barL : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B) + -- Three families of lepton singlets + derivatives + conjugates + (e : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B) + (bare : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B) + : Prop where + -- *Gauge transformation* + -- Every field transforms homogeneously under the global gauge group, which acts on + -- the dual value index through the dual (contragredient) of the species + -- representation — the conjugate representation for the barred fields, and the + -- adjoint action for the field strength. The gauge action on the algebra is + -- multiplicative. + repGauge_mul : ∀ (g : GaugeGroupI) (b₁ b₂ : B), + repGauge g (b₁ * b₂) = repGauge g b₁ * repGauge g b₂ + repGauge_H : ∀ (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec), + repGauge g (H l φ) = H l (HiggsVec.repGaugeGroupI.dual g φ) + repGauge_barH : ∀ (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), + repGauge g (barH l φ) = barH l (HiggsVec.repGaugeGroupI.conj.dual g φ) + repGauge_F : ∀ (g : GaugeGroupI) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + repGauge g (F l μ ν φ) = F l μ ν ((GaugeAlgebra.adjointMap g⁻¹).dualMap φ) + repGauge_d : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet), + repGauge g (d i l φ) = d i l (DownSinglet.repGaugeGroupI.dual g φ) + repGauge_bard : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)), + repGauge g (bard i l φ) = bard i l (DownSinglet.repGaugeGroupI.conj.dual g φ) + repGauge_u : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet), + repGauge g (u i l φ) = u i l (UpSinglet.repGaugeGroupI.dual g φ) + repGauge_baru : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)), + repGauge g (baru i l φ) = baru i l (UpSinglet.repGaugeGroupI.conj.dual g φ) + repGauge_Q : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet), + repGauge g (Q i l φ) = Q i l (QuarkDoublet.repGaugeGroupI.dual g φ) + repGauge_barQ : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + repGauge g (barQ i l φ) = barQ i l (QuarkDoublet.repGaugeGroupI.conj.dual g φ) + repGauge_L : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonDoublet), + repGauge g (L i l φ) = L i l (LeptonDoublet.repGaugeGroupI.dual g φ) + repGauge_barL : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + repGauge g (barL i l φ) = barL i l (LeptonDoublet.repGaugeGroupI.conj.dual g φ) + repGauge_e : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonSinglet), + repGauge g (e i l φ) = e i l (LeptonSinglet.repGaugeGroupI.dual g φ) + repGauge_bare : ∀ (g : GaugeGroupI) (i : Fin 3) {n : ℕ} + (l : Fin n → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + repGauge g (bare i l φ) = bare i l (LeptonSinglet.repGaugeGroupI.conj.dual g φ) + -- *Lorentz transformation* + -- Every field together with its covariant derivatives transforms as a Lorentz + -- tensor: each covariant-derivative slot mixes by the Lorentz matrix (ordered + -- tuples, since covariant derivatives need not commute) and the value index by the + -- contragredient of the species' Lorentz representation — the conjugate + -- representation for the barred fields. The two covector indices of the field + -- strength are explicit, and each mixes by the Lorentz matrix. The Lorentz action + -- on the algebra is multiplicative. + repLorentz_mul : ∀ (Λ : SL(2,ℂ)) (b₁ b₂ : B), + repLorentz Λ (b₁ * b₂) = repLorentz Λ b₁ * repLorentz Λ b₂ + repLorentz_H : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) H + repLorentz_barH : IsLorentzCovDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj barH + repLorentz_F : ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra), + repLorentz Λ (F l μ ν φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + ∑ b, (((SL2C.toLorentzGroup Λ).1 b ν : ℝ) : ℂ) • F p a b φ + repLorentz_d : ∀ i, IsLorentzCovDerivTransforms repLorentz + DownSinglet.repLorentzGroup (d i) + repLorentz_bard : ∀ i, IsLorentzCovDerivTransforms repLorentz + DownSinglet.repLorentzGroup.conj (bard i) + repLorentz_u : ∀ i, IsLorentzCovDerivTransforms repLorentz + UpSinglet.repLorentzGroup (u i) + repLorentz_baru : ∀ i, IsLorentzCovDerivTransforms repLorentz + UpSinglet.repLorentzGroup.conj (baru i) + repLorentz_Q : ∀ i, IsLorentzCovDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup (Q i) + repLorentz_barQ : ∀ i, IsLorentzCovDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup.conj (barQ i) + repLorentz_L : ∀ i, IsLorentzCovDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup (L i) + repLorentz_barL : ∀ i, IsLorentzCovDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup.conj (barL i) + repLorentz_e : ∀ i, IsLorentzCovDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup (e i) + repLorentz_bare : ∀ i, IsLorentzCovDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup.conj (bare i) + -- **Mass weights (= 2 * mass dimension)** + -- Every covariant tower is a `massWeightPoly`-eigenvector of pure monomial weight: + -- each covariant derivative adds one to the mass dimension, so the Higgs towers + -- have mass dimension `1 + n` (weight `2 * (1 + n)`), the field-strength towers + -- mass dimension `2 + n` (weight `2 * (2 + n)`), and the fermion towers mass + -- dimension `3/2 + n` (weight `3 + 2 * n`) + massWeight_H : ∀ {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (H l φ) = Polynomial.monomial (2 * (1 + n)) (H l φ) + massWeight_barH : ∀ {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (barH l φ) = Polynomial.monomial (2 * (1 + n)) (barH l φ) + massWeight_F : ∀ {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) φ, + massWeightPoly (F l μ ν φ) = Polynomial.monomial (2 * (2 + n)) (F l μ ν φ) + massWeight_d : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (d i l φ) = Polynomial.monomial (3 + 2 * n) (d i l φ) + massWeight_bard : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (bard i l φ) = Polynomial.monomial (3 + 2 * n) (bard i l φ) + massWeight_u : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (u i l φ) = Polynomial.monomial (3 + 2 * n) (u i l φ) + massWeight_baru : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (baru i l φ) = Polynomial.monomial (3 + 2 * n) (baru i l φ) + massWeight_Q : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (Q i l φ) = Polynomial.monomial (3 + 2 * n) (Q i l φ) + massWeight_barQ : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (barQ i l φ) = Polynomial.monomial (3 + 2 * n) (barQ i l φ) + massWeight_L : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (L i l φ) = Polynomial.monomial (3 + 2 * n) (L i l φ) + massWeight_barL : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (barL i l φ) = Polynomial.monomial (3 + 2 * n) (barL i l φ) + massWeight_e : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (e i l φ) = Polynomial.monomial (3 + 2 * n) (e i l φ) + massWeight_bare : ∀ i {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) φ, + massWeightPoly (bare i l φ) = Polynomial.monomial (3 + 2 * n) (bare i l φ) + -- **The commutation rules** + -- The gauge sector is bosonic: every field-strength tower commutes with every + -- field. + F_comm_F : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (l' : Fin m → Fin 1 ⊕ Fin 3) + (μ' ν' : Fin 1 ⊕ Fin 3) (ψ' : Module.Dual ℝ GaugeAlgebra), + Commute (F l μ ν ψ) (F l' μ' ν' ψ') + F_comm_H : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec), + Commute (F l μ ν ψ) (H l' φ) + F_comm_barH : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), + Commute (F l μ ν ψ) (barH l' φ) + F_comm_d : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ DownSinglet), + Commute (F l μ ν ψ) (d i l' φ) + F_comm_bard : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), + Commute (F l μ ν ψ) (bard i l' φ) + F_comm_u : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ UpSinglet), + Commute (F l μ ν ψ) (u i l' φ) + F_comm_baru : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), + Commute (F l μ ν ψ) (baru i l' φ) + F_comm_Q : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ QuarkDoublet), + Commute (F l μ ν ψ) (Q i l' φ) + F_comm_barQ : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + Commute (F l μ ν ψ) (barQ i l' φ) + F_comm_L : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonDoublet), + Commute (F l μ ν ψ) (L i l' φ) + F_comm_barL : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + Commute (F l μ ν ψ) (barL i l' φ) + F_comm_e : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonSinglet), + Commute (F l μ ν ψ) (e i l' φ) + F_comm_bare : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + Commute (F l μ ν ψ) (bare i l' φ) + -- The Higgs sector is bosonic: the Higgs towers and their conjugates commute + -- with each other and with every fermion. + H_comm_H : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ HiggsVec), + Commute (H l φ) (H l' φ') + H_comm_barH : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule HiggsVec)), + Commute (H l φ) (barH l' φ') + barH_comm_barH : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule HiggsVec)), + Commute (barH l φ) (barH l' φ') + H_comm_d : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ DownSinglet), + Commute (H l φ) (d i l' φ') + H_comm_bard : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)), + Commute (H l φ) (bard i l' φ') + H_comm_u : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ UpSinglet), + Commute (H l φ) (u i l' φ') + H_comm_baru : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + Commute (H l φ) (baru i l' φ') + H_comm_Q : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ QuarkDoublet), + Commute (H l φ) (Q i l' φ') + H_comm_barQ : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + Commute (H l φ) (barQ i l' φ') + H_comm_L : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ LeptonDoublet), + Commute (H l φ) (L i l' φ') + H_comm_barL : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + Commute (H l φ) (barL i l' φ') + H_comm_e : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ LeptonSinglet), + Commute (H l φ) (e i l' φ') + H_comm_bare : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + Commute (H l φ) (bare i l' φ') + barH_comm_d : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ DownSinglet), + Commute (barH l φ) (d i l' φ') + barH_comm_bard : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)), + Commute (barH l φ) (bard i l' φ') + barH_comm_u : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ UpSinglet), + Commute (barH l φ) (u i l' φ') + barH_comm_baru : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + Commute (barH l φ) (baru i l' φ') + barH_comm_Q : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ QuarkDoublet), + Commute (barH l φ) (Q i l' φ') + barH_comm_barQ : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + Commute (barH l φ) (barQ i l' φ') + barH_comm_L : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ LeptonDoublet), + Commute (barH l φ) (L i l' φ') + barH_comm_barL : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + Commute (barH l φ) (barL i l' φ') + barH_comm_e : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ LeptonSinglet), + Commute (barH l φ) (e i l' φ') + barH_comm_bare : ∀ {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (i : Fin 3) (l' : Fin m → Fin 1 ⊕ Fin 3) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + Commute (barH l φ) (bare i l' φ') + -- The fermion sector: any two fermionic towers anticommute. On the diagonal + -- (same species, family, derivative slots and dual vector) this forces the + -- square of every fermionic symbol to vanish, since `2` is invertible in `B`. + d_anticomm_d : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ DownSinglet), + d i l φ * d j l' φ' = -(d j l' φ' * d i l φ) + d_anticomm_bard : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)), + d i l φ * bard j l' φ' = -(bard j l' φ' * d i l φ) + d_anticomm_u : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ UpSinglet), + d i l φ * u j l' φ' = -(u j l' φ' * d i l φ) + d_anticomm_baru : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + d i l φ * baru j l' φ' = -(baru j l' φ' * d i l φ) + d_anticomm_Q : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ QuarkDoublet), + d i l φ * Q j l' φ' = -(Q j l' φ' * d i l φ) + d_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + d i l φ * barQ j l' φ' = -(barQ j l' φ' * d i l φ) + d_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ LeptonDoublet), + d i l φ * L j l' φ' = -(L j l' φ' * d i l φ) + d_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + d i l φ * barL j l' φ' = -(barL j l' φ' * d i l φ) + d_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ LeptonSinglet), + d i l φ * e j l' φ' = -(e j l' φ' * d i l φ) + d_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ DownSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + d i l φ * bare j l' φ' = -(bare j l' φ' * d i l φ) + bard_anticomm_bard : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule DownSinglet)), + bard i l φ * bard j l' φ' = -(bard j l' φ' * bard i l φ) + bard_anticomm_u : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ UpSinglet), + bard i l φ * u j l' φ' = -(u j l' φ' * bard i l φ) + bard_anticomm_baru : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + bard i l φ * baru j l' φ' = -(baru j l' φ' * bard i l φ) + bard_anticomm_Q : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ QuarkDoublet), + bard i l φ * Q j l' φ' = -(Q j l' φ' * bard i l φ) + bard_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + bard i l φ * barQ j l' φ' = -(barQ j l' φ' * bard i l φ) + bard_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ LeptonDoublet), + bard i l φ * L j l' φ' = -(L j l' φ' * bard i l φ) + bard_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + bard i l φ * barL j l' φ' = -(barL j l' φ' * bard i l φ) + bard_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ LeptonSinglet), + bard i l φ * e j l' φ' = -(e j l' φ' * bard i l φ) + bard_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule DownSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + bard i l φ * bare j l' φ' = -(bare j l' φ' * bard i l φ) + u_anticomm_u : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ UpSinglet), + u i l φ * u j l' φ' = -(u j l' φ' * u i l φ) + u_anticomm_baru : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + u i l φ * baru j l' φ' = -(baru j l' φ' * u i l φ) + u_anticomm_Q : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ QuarkDoublet), + u i l φ * Q j l' φ' = -(Q j l' φ' * u i l φ) + u_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + u i l φ * barQ j l' φ' = -(barQ j l' φ' * u i l φ) + u_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ LeptonDoublet), + u i l φ * L j l' φ' = -(L j l' φ' * u i l φ) + u_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + u i l φ * barL j l' φ' = -(barL j l' φ' * u i l φ) + u_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ LeptonSinglet), + u i l φ * e j l' φ' = -(e j l' φ' * u i l φ) + u_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ UpSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + u i l φ * bare j l' φ' = -(bare j l' φ' * u i l φ) + baru_anticomm_baru : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule UpSinglet)), + baru i l φ * baru j l' φ' = -(baru j l' φ' * baru i l φ) + baru_anticomm_Q : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ QuarkDoublet), + baru i l φ * Q j l' φ' = -(Q j l' φ' * baru i l φ) + baru_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + baru i l φ * barQ j l' φ' = -(barQ j l' φ' * baru i l φ) + baru_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ LeptonDoublet), + baru i l φ * L j l' φ' = -(L j l' φ' * baru i l φ) + baru_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + baru i l φ * barL j l' φ' = -(barL j l' φ' * baru i l φ) + baru_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ LeptonSinglet), + baru i l φ * e j l' φ' = -(e j l' φ' * baru i l φ) + baru_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule UpSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + baru i l φ * bare j l' φ' = -(bare j l' φ' * baru i l φ) + Q_anticomm_Q : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ QuarkDoublet), + Q i l φ * Q j l' φ' = -(Q j l' φ' * Q i l φ) + Q_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + Q i l φ * barQ j l' φ' = -(barQ j l' φ' * Q i l φ) + Q_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ LeptonDoublet), + Q i l φ * L j l' φ' = -(L j l' φ' * Q i l φ) + Q_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + Q i l φ * barL j l' φ' = -(barL j l' φ' * Q i l φ) + Q_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ LeptonSinglet), + Q i l φ * e j l' φ' = -(e j l' φ' * Q i l φ) + Q_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ QuarkDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + Q i l φ * bare j l' φ' = -(bare j l' φ' * Q i l φ) + barQ_anticomm_barQ : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ (ConjModule QuarkDoublet)), + barQ i l φ * barQ j l' φ' = -(barQ j l' φ' * barQ i l φ) + barQ_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ LeptonDoublet), + barQ i l φ * L j l' φ' = -(L j l' φ' * barQ i l φ) + barQ_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + barQ i l φ * barL j l' φ' = -(barL j l' φ' * barQ i l φ) + barQ_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ LeptonSinglet), + barQ i l φ * e j l' φ' = -(e j l' φ' * barQ i l φ) + barQ_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + barQ i l φ * bare j l' φ' = -(bare j l' φ' * barQ i l φ) + L_anticomm_L : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ LeptonDoublet), + L i l φ * L j l' φ' = -(L j l' φ' * L i l φ) + L_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + L i l φ * barL j l' φ' = -(barL j l' φ' * L i l φ) + L_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ LeptonSinglet), + L i l φ * e j l' φ' = -(e j l' φ' * L i l φ) + L_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonDoublet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + L i l φ * bare j l' φ' = -(bare j l' φ' * L i l φ) + barL_anticomm_barL : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonDoublet)), + barL i l φ * barL j l' φ' = -(barL j l' φ' * barL i l φ) + barL_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) + (φ' : Module.Dual ℂ LeptonSinglet), + barL i l φ * e j l' φ' = -(e j l' φ' * barL i l φ) + barL_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + barL i l φ * bare j l' φ' = -(bare j l' φ' * barL i l φ) + e_anticomm_e : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonSinglet) + (φ' : Module.Dual ℂ LeptonSinglet), + e i l φ * e j l' φ' = -(e j l' φ' * e i l φ) + e_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ LeptonSinglet) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + e i l φ * bare j l' φ' = -(bare j l' φ' * e i l φ) + bare_anticomm_bare : ∀ (i j : Fin 3) {n m : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (l' : Fin m → Fin 1 ⊕ Fin 3) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) + (φ' : Module.Dual ℂ (ConjModule LeptonSinglet)), + bare i l φ * bare j l' φ' = -(bare j l' φ' * bare i l φ) + +namespace IsCovStandardModel + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + {H : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B} + {barH : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B} + {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {d : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B} + {bard : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B} + {u : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B} + {baru : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B} + {Q : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B} + {barQ : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B} + {L : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B} + {barL : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B} + {e : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B} + {bare : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B} + (h : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) + +/-! + +## A. The gauge and Lorentz actions + +The two actions on the algebra are multiplicative, so each is a unital algebra +automorphism; in particular each fixes the unit. + +-/ + +include h in +/-- The multiplicative gauge action fixes the unit of the algebra. -/ +lemma repGauge_one (g : GaugeGroupI) : repGauge g (1 : B) = 1 := by + obtain ⟨u, hu⟩ : ∃ u, repGauge g u = 1 := + ⟨repGauge g⁻¹ 1, by + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repGauge, + Module.End.one_apply]⟩ + have h1 := h.repGauge_mul g u 1 + rw [mul_one, hu, one_mul] at h1 + exact h1.symm + +include h in +/-- The multiplicative Lorentz action fixes the unit of the algebra. -/ +lemma repLorentz_one (Λ : SL(2,ℂ)) : repLorentz Λ (1 : B) = 1 := by + obtain ⟨u, hu⟩ : ∃ u, repLorentz Λ u = 1 := + ⟨repLorentz Λ⁻¹ 1, by + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one repLorentz, + Module.End.one_apply]⟩ + have h1 := h.repLorentz_mul Λ u 1 + rw [mul_one, hu, one_mul] at h1 + exact h1.symm + +/-! + +## B. The field algebra + +-/ + +/-- The algebra generated by all the covariant fields of the Standard Model: the + covariant-derivative towers of the field strength, of the Higgs and its conjugate, + and of the three families of each fermion species with their conjugates. -/ +def fieldAlgebra (_ : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) : Subalgebra ℂ B := + Algebra.adjoin ℂ + ((⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3), + Set.range (F l μ ν)) ∪ + (⋃ (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), Set.range (H l) ∪ Set.range (barH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → Fin 1 ⊕ Fin 3), + Set.range (d i l) ∪ Set.range (bard i l) ∪ + Set.range (u i l) ∪ Set.range (baru i l) ∪ + Set.range (Q i l) ∪ Set.range (barQ i l) ∪ + Set.range (L i l) ∪ Set.range (barL i l) ∪ + Set.range (e i l) ∪ Set.range (bare i l))) + +/-! + +### B.1. Basic commutation relations + +-/ + +lemma F_commute_mem_fieldAlgebra {n : ℕ} {l : Fin n → Fin 1 ⊕ Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (φ : Module.Dual ℝ GaugeAlgebra) (x : B) (hx : x ∈ h.fieldAlgebra) : + F l μ ν φ * x = x * F l μ ν φ := by + rw [fieldAlgebra] at hx + refine (IsGaugeField.commute_of_mem_adjoin (y := F l μ ν φ) ?_ hx).symm + intro z hz + simp only [Set.mem_union, Set.mem_iUnion, Set.mem_range] at hz + obtain ((⟨n', l', μ', ν', ψ, rfl⟩ | ⟨n', l', ⟨φ', rfl⟩ | ⟨φ', rfl⟩⟩) | ⟨i, n', l', hz⟩) := hz + · exact (h.F_comm_F l μ ν φ l' μ' ν' ψ).symm + · exact (h.F_comm_H l μ ν φ l' φ').symm + · exact (h.F_comm_barH l μ ν φ l' φ').symm + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (h.F_comm_d l μ ν φ i l' φ').symm + · exact (h.F_comm_bard l μ ν φ i l' φ').symm + · exact (h.F_comm_u l μ ν φ i l' φ').symm + · exact (h.F_comm_baru l μ ν φ i l' φ').symm + · exact (h.F_comm_Q l μ ν φ i l' φ').symm + · exact (h.F_comm_barQ l μ ν φ i l' φ').symm + · exact (h.F_comm_L l μ ν φ i l' φ').symm + · exact (h.F_comm_barL l μ ν φ i l' φ').symm + · exact (h.F_comm_e l μ ν φ i l' φ').symm + · exact (h.F_comm_bare l μ ν φ i l' φ').symm + +lemma H_commute_mem_fieldAlgebra {n : ℕ} {l : Fin n → Fin 1 ⊕ Fin 3} + (φ : Module.Dual ℂ HiggsVec) (x : B) (hx : x ∈ h.fieldAlgebra) : + H l φ * x = x * H l φ := by + rw [fieldAlgebra] at hx + refine (IsGaugeField.commute_of_mem_adjoin (y := H l φ) ?_ hx).symm + intro z hz + simp only [Set.mem_union, Set.mem_iUnion, Set.mem_range] at hz + obtain ((⟨n', l', μ', ν', ψ, rfl⟩ | ⟨n', l', ⟨φ', rfl⟩ | ⟨φ', rfl⟩⟩) | ⟨i, n', l', hz⟩) := hz + · exact h.F_comm_H l' μ' ν' ψ l φ + · exact h.H_comm_H l' φ' l φ + · exact (h.H_comm_barH l φ l' φ').symm + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (h.H_comm_d l φ i l' φ').symm + · exact (h.H_comm_bard l φ i l' φ').symm + · exact (h.H_comm_u l φ i l' φ').symm + · exact (h.H_comm_baru l φ i l' φ').symm + · exact (h.H_comm_Q l φ i l' φ').symm + · exact (h.H_comm_barQ l φ i l' φ').symm + · exact (h.H_comm_L l φ i l' φ').symm + · exact (h.H_comm_barL l φ i l' φ').symm + · exact (h.H_comm_e l φ i l' φ').symm + · exact (h.H_comm_bare l φ i l' φ').symm + +lemma barH_commute_mem_fieldAlgebra {n : ℕ} {l : Fin n → Fin 1 ⊕ Fin 3} + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (x : B) (hx : x ∈ h.fieldAlgebra) : + barH l φ * x = x * barH l φ := by + rw [fieldAlgebra] at hx + refine (IsGaugeField.commute_of_mem_adjoin (y := barH l φ) ?_ hx).symm + intro z hz + simp only [Set.mem_union, Set.mem_iUnion, Set.mem_range] at hz + obtain ((⟨n', l', μ', ν', ψ, rfl⟩ | ⟨n', l', ⟨φ', rfl⟩ | ⟨φ', rfl⟩⟩) | ⟨i, n', l', hz⟩) := hz + · exact h.F_comm_barH l' μ' ν' ψ l φ + · exact h.H_comm_barH l' φ' l φ + · exact h.barH_comm_barH l' φ' l φ + · obtain (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) := hz + · exact (h.barH_comm_d l φ i l' φ').symm + · exact (h.barH_comm_bard l φ i l' φ').symm + · exact (h.barH_comm_u l φ i l' φ').symm + · exact (h.barH_comm_baru l φ i l' φ').symm + · exact (h.barH_comm_Q l φ i l' φ').symm + · exact (h.barH_comm_barQ l φ i l' φ').symm + · exact (h.barH_comm_L l φ i l' φ').symm + · exact (h.barH_comm_barL l φ i l' φ').symm + · exact (h.barH_comm_e l φ i l' φ').symm + · exact (h.barH_comm_bare l φ i l' φ').symm + +end IsCovStandardModel + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/Generators.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/Generators.lean new file mode 100644 index 000000000..82f2d5331 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsCovStandardModel/Generators.lean @@ -0,0 +1,1326 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.IsCovStandardModel.Basic +public import Mathlib.Algebra.Algebra.NonUnitalSubalgebra +/-! +# The covariant generators of the field algebra + +The covariant fields, indexed abstractly: `Generators` names one covariant tower +applied to a member of the dual basis of its value space, and `generatorVal` evaluates +it in the algebra. Only basis indices are stored, so the generators of a given mass +weight form a finite type. The field algebra is generated by these values +(`fieldAlgebra_eq_adjoin_range`), and they supercommute — the weight of a generator is +odd exactly when it is fermionic. + +The grading of the algebra by mass weight is in `IsCovStandardModel.MassWeight`. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + + +namespace IsCovStandardModel + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + {H : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B} + {barH : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B} + {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {d : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B} + {bard : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B} + {u : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B} + {baru : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B} + {Q : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B} + {barQ : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B} + {L : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B} + {barL : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B} + {e : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B} + {bare : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B} + (h : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) + +/-! + +## A. Derivative collections + +-/ + + +/-- The abstract index of a single covariant generator of the field algebra: one of + the covariant-derivative towers of the field strength, of the Higgs and its + conjugate, or of the three families of each fermion species and their conjugates, + applied to a member of the dual basis of its value space. Only basis indices are + stored, so for a fixed tower length the generators of a given mass weight form a + finite type. The evaluation in `B` is `generatorVal`. -/ +inductive Generators where + /-- The Higgs tower `∇_l H` applied to a dual basis vector. -/ + | H : (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 → Generators + /-- The conjugate-Higgs tower `∇_l H̄` applied to a dual basis vector. -/ + | barH : (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 → Generators + /-- The field-strength tower `∇_l F_μν` applied to a dual basis vector. -/ + | F : (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → + (Fin 8 ⊕ Fin 3 ⊕ Fin 1) → Generators + /-- The fermion tower `∇_l d` of the `i`-th family applied to a dual basis vector. -/ + | d : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 → Generators + /-- The fermion tower `∇_l bard` of the `i`-th family applied to a dual basis vector. -/ + | bard : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 → Generators + /-- The fermion tower `∇_l u` of the `i`-th family applied to a dual basis vector. -/ + | u : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 → Generators + /-- The fermion tower `∇_l baru` of the `i`-th family applied to a dual basis vector. -/ + | baru : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 → Generators + /-- The fermion tower `∇_l Q` of the `i`-th family applied to a dual basis vector. -/ + | Q : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 × Fin 2 → Generators + /-- The fermion tower `∇_l barQ` of the `i`-th family applied to a dual basis vector. -/ + | barQ : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 3 × Fin 2 → Generators + /-- The fermion tower `∇_l L` of the `i`-th family applied to a dual basis vector. -/ + | L : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Generators + /-- The fermion tower `∇_l barL` of the `i`-th family applied to a dual basis vector. -/ + | barL : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 × Fin 2 → Generators + /-- The fermion tower `∇_l e` of the `i`-th family applied to a dual basis vector. -/ + | e : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 → Generators + /-- The fermion tower `∇_l bare` of the `i`-th family applied to a dual basis vector. -/ + | bare : Fin 3 → (n : ℕ) → (Fin n → Fin 1 ⊕ Fin 3) → Fin 2 → Generators +deriving DecidableEq + +namespace Generators + +def IsFermionic : Generators → Prop + | .H _ _ _ => False + | .barH _ _ _ => False + | .F _ _ _ _ _ => False + | .d _ _ _ _ => True + | .bard _ _ _ _ => True + | .u _ _ _ _ => True + | .baru _ _ _ _ => True + | .Q _ _ _ _ => True + | .barQ _ _ _ _ => True + | .L _ _ _ _ => True + | .barL _ _ _ _ => True + | .e _ _ _ _ => True + | .bare _ _ _ _ => True + +/-- The Higgs generators: the covariant towers of the Higgs field and of its + conjugate. -/ +def IsHiggs : Generators → Prop + | .H _ _ _ => True + | .barH _ _ _ => True + | _ => False + +def IsGaugeField : Generators → Prop + | .F _ _ _ _ _ => True + | _ => False + +/-- The number of derivatives for a given generator. -/ +def toNumDerivatives : Generators → ℕ + | .H n _ _ => n + | .barH n _ _ => n + | .F n _ _ _ _ => n + | .d _ n _ _ => n + | .bard _ n _ _ => n + | .u _ n _ _ => n + | .baru _ n _ _ => n + | .Q _ n _ _ => n + | .barQ _ n _ _ => n + | .L _ n _ _ => n + | .barL _ n _ _ => n + | .e _ n _ _ => n + | .bare _ n _ _ => n + +end Generators +/-! + +## B. Covariant generators + +-/ + +/-- The mass weight (twice the mass dimension) of a covariant generator. -/ +def Generators.weight : Generators → ℕ + | .H n _ _ => 2 * (1 + n) + | .barH n _ _ => 2 * (1 + n) + | .F n _ _ _ _ => 2 * (2 + n) + | .d _ n _ _ => 3 + 2 * n + | .bard _ n _ _ => 3 + 2 * n + | .u _ n _ _ => 3 + 2 * n + | .baru _ n _ _ => 3 + 2 * n + | .Q _ n _ _ => 3 + 2 * n + | .barQ _ n _ _ => 3 + 2 * n + | .L _ n _ _ => 3 + 2 * n + | .barL _ n _ _ => 3 + 2 * n + | .e _ n _ _ => 3 + 2 * n + | .bare _ n _ _ => 3 + 2 * n + +set_option linter.unusedVariables false in +/-- The value in `B` of a covariant generator: the corresponding covariant tower + applied to the indicated dual basis vector of its value space. -/ +noncomputable def generatorVal + (h : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) : Generators → B + | .H _ l j => H l (HiggsVec.orthonormBasis.toBasis.coord j) + | .barH _ l j => barH l (HiggsVec.orthonormBasis.toBasis.conj.coord j) + | .F _ l μ ν j => F l μ ν (GaugeAlgebra.stdBasis.coord j) + | .d i _ l j => d i l (DownSinglet.basis.coord j) + | .bard i _ l j => bard i l (DownSinglet.basis.conj.coord j) + | .u i _ l j => u i l (UpSinglet.basis.coord j) + | .baru i _ l j => baru i l (UpSinglet.basis.conj.coord j) + | .Q i _ l j => Q i l (QuarkDoublet.basis.coord j) + | .barQ i _ l j => barQ i l (QuarkDoublet.basis.conj.coord j) + | .L i _ l j => L i l (LeptonDoublet.basis.coord j) + | .barL i _ l j => barL i l (LeptonDoublet.basis.conj.coord j) + | .e i _ l j => e i l (LeptonSinglet.basis.coord j) + | .bare i _ l j => bare i l (LeptonSinglet.basis.conj.coord j) + +/-- Every covariant generator is a `massWeightPoly`-eigenvector of its weight. -/ +lemma massWeightPoly_generatorVal (g : Generators) : + massWeightPoly (h.generatorVal g) = Polynomial.monomial g.weight (h.generatorVal g) := by + cases g with + | H n l j => exact h.massWeight_H l _ + | barH n l j => exact h.massWeight_barH l _ + | F n l μ ν j => exact h.massWeight_F l μ ν _ + | d i n l j => exact h.massWeight_d i l _ + | bard i n l j => exact h.massWeight_bard i l _ + | u i n l j => exact h.massWeight_u i l _ + | baru i n l j => exact h.massWeight_baru i l _ + | Q i n l j => exact h.massWeight_Q i l _ + | barQ i n l j => exact h.massWeight_barQ i l _ + | L i n l j => exact h.massWeight_L i l _ + | barL i n l j => exact h.massWeight_barL i l _ + | e i n l j => exact h.massWeight_e i l _ + | bare i n l j => exact h.massWeight_bare i l _ + +lemma generatorVal_mem_fieldAlgebra (g : Generators) : + h.generatorVal g ∈ h.fieldAlgebra := by + rw [fieldAlgebra] + refine Algebra.subset_adjoin ?_ + cases g with + | F n l μ ν j => + exact Set.mem_union_left _ (Set.mem_union_left _ + (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Set.mem_iUnion.mpr ⟨μ, + Set.mem_iUnion.mpr ⟨ν, ⟨_, rfl⟩⟩⟩⟩⟩)) + | H n l j => + exact Set.mem_union_left _ (Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Set.mem_union_left _ ⟨_, rfl⟩⟩⟩)) + | barH n l j => + exact Set.mem_union_left _ (Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, Set.mem_union_right _ ⟨_, rfl⟩⟩⟩)) + | d i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (⟨_, rfl⟩)))))))))⟩⟩⟩) + | bard i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩))))))))⟩⟩⟩) + | u i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩)))))))⟩⟩⟩) + | baru i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩))))))⟩⟩⟩) + | Q i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩)))))⟩⟩⟩) + | barQ i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩))))⟩⟩⟩) + | L i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩)))⟩⟩⟩) + | barL i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩))⟩⟩⟩) + | e i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_left _ (Set.mem_union_right _ ⟨_, rfl⟩)⟩⟩⟩) + | bare i n l j => + exact Set.mem_union_right _ + (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, + Set.mem_union_right _ ⟨_, rfl⟩⟩⟩⟩) + +/-- Expanding every dual vector in the dual basis of its value space: the field + algebra is already generated by the countable family of basis generators. -/ +lemma fieldAlgebra_le_adjoin_range : + h.fieldAlgebra ≤ Algebra.adjoin ℂ (Set.range h.generatorVal) := by + rw [fieldAlgebra] + refine Algebra.adjoin_le fun x hx => ?_ + simp only [Set.mem_union, Set.mem_iUnion, Set.mem_range] at hx + obtain ((⟨n, l, μ, ν, φ, rfl⟩ | ⟨n, l, ⟨φ, rfl⟩ | ⟨φ, rfl⟩⟩) | ⟨i, n, l, hx⟩) := hx + · rw [← GaugeAlgebra.stdBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Subalgebra.sum_mem _ fun j _ => ?_ + rw [← algebraMap_smul ℂ (φ (GaugeAlgebra.stdBasis j))] + exact Subalgebra.smul_mem _ (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.F n l μ ν j))) _ + · rw [← HiggsVec.orthonormBasis.toBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.H n l j))) _ + · rw [← HiggsVec.orthonormBasis.toBasis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.barH n l j))) _ + · obtain (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) := hx + · rw [← DownSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.d i n l j))) _ + · rw [← DownSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.bard i n l j))) _ + · rw [← UpSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.u i n l j))) _ + · rw [← UpSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.baru i n l j))) _ + · rw [← QuarkDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.Q i n l j))) _ + · rw [← QuarkDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.barQ i n l j))) _ + · rw [← LeptonDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.L i n l j))) _ + · rw [← LeptonDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.barL i n l j))) _ + · rw [← LeptonSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.e i n l j))) _ + · rw [← LeptonSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + exact Subalgebra.sum_mem _ fun j _ => Subalgebra.smul_mem _ + (Algebra.subset_adjoin + (Set.mem_range_self (f := h.generatorVal) (Generators.bare i n l j))) _ + +/-- The field algebra is generated by the covariant basis generators. -/ +lemma fieldAlgebra_eq_adjoin_range : + h.fieldAlgebra = Algebra.adjoin ℂ (Set.range h.generatorVal) := by + refine le_antisymm h.fieldAlgebra_le_adjoin_range (Algebra.adjoin_le ?_) + rintro x ⟨g, rfl⟩ + exact h.generatorVal_mem_fieldAlgebra g + +/-- A list of generator values is the list of values of a list of generators. -/ +lemma exists_list_map_eq (l₀ : List B) : + (∀ y ∈ l₀, y ∈ Set.range h.generatorVal) → + ∃ gl : List Generators, gl.map h.generatorVal = l₀ := by + induction l₀ with + | nil => exact fun _ => ⟨[], rfl⟩ + | cons a t ih => + intro hl₀ + obtain ⟨g, hg⟩ := hl₀ a (by simp) + obtain ⟨gl, hgl⟩ := ih (fun y hy => hl₀ y (by simp [hy])) + exact ⟨g :: gl, by rw [List.map_cons, hg, hgl]⟩ + +/-- A word in the covariant generators is a `massWeightPoly`-eigenvector whose + weight is the sum of the weights of its factors. -/ +lemma massWeightPoly_generatorVal_list_prod (gl : List Generators) : + massWeightPoly ((gl.map h.generatorVal).prod) = + Polynomial.monomial ((gl.map Generators.weight).sum) ((gl.map h.generatorVal).prod) := by + induction gl with + | nil => simp + | cons g t ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons, map_mul, + h.massWeightPoly_generatorVal, ih, Polynomial.monomial_mul_monomial] +/-! + +## C. Supercommutativity of the generators + +The mass weight doubles as the super-grading: the weight of a covariant generator +is odd exactly when the generator is fermionic. Two generators therefore exchange +up to the sign `(-1) ^ (weight * weight)`, and words of generators up to the sign +of the product of their total weights. + +-/ + +/-- The field-strength symbols commute with the value of every covariant + generator. -/ +lemma commute_F_generatorVal {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (g : Generators) : + Commute (F l μ ν ψ) (h.generatorVal g) := by + cases g with + | H n' l' j => exact h.F_comm_H l μ ν ψ l' _ + | barH n' l' j => exact h.F_comm_barH l μ ν ψ l' _ + | F n' l' μ' ν' j => exact h.F_comm_F l μ ν ψ l' μ' ν' _ + | d i n' l' j => exact h.F_comm_d l μ ν ψ i l' _ + | bard i n' l' j => exact h.F_comm_bard l μ ν ψ i l' _ + | u i n' l' j => exact h.F_comm_u l μ ν ψ i l' _ + | baru i n' l' j => exact h.F_comm_baru l μ ν ψ i l' _ + | Q i n' l' j => exact h.F_comm_Q l μ ν ψ i l' _ + | barQ i n' l' j => exact h.F_comm_barQ l μ ν ψ i l' _ + | L i n' l' j => exact h.F_comm_L l μ ν ψ i l' _ + | barL i n' l' j => exact h.F_comm_barL l μ ν ψ i l' _ + | e i n' l' j => exact h.F_comm_e l μ ν ψ i l' _ + | bare i n' l' j => exact h.F_comm_bare l μ ν ψ i l' _ + +/-- The Higgs symbols commute with the value of every covariant generator. -/ +lemma commute_H_generatorVal {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) (g : Generators) : + Commute (H l φ) (h.generatorVal g) := by + cases g with + | H n' l' j => exact h.H_comm_H l φ l' _ + | barH n' l' j => exact h.H_comm_barH l φ l' _ + | F n' l' μ' ν' j => exact (h.F_comm_H l' μ' ν' _ l φ).symm + | d i n' l' j => exact h.H_comm_d l φ i l' _ + | bard i n' l' j => exact h.H_comm_bard l φ i l' _ + | u i n' l' j => exact h.H_comm_u l φ i l' _ + | baru i n' l' j => exact h.H_comm_baru l φ i l' _ + | Q i n' l' j => exact h.H_comm_Q l φ i l' _ + | barQ i n' l' j => exact h.H_comm_barQ l φ i l' _ + | L i n' l' j => exact h.H_comm_L l φ i l' _ + | barL i n' l' j => exact h.H_comm_barL l φ i l' _ + | e i n' l' j => exact h.H_comm_e l φ i l' _ + | bare i n' l' j => exact h.H_comm_bare l φ i l' _ + +/-- The conjugate-Higgs symbols commute with the value of every covariant + generator. -/ +lemma commute_barH_generatorVal {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) (g : Generators) : + Commute (barH l φ) (h.generatorVal g) := by + cases g with + | H n' l' j => exact (h.H_comm_barH l' _ l φ).symm + | barH n' l' j => exact h.barH_comm_barH l φ l' _ + | F n' l' μ' ν' j => exact (h.F_comm_barH l' μ' ν' _ l φ).symm + | d i n' l' j => exact h.barH_comm_d l φ i l' _ + | bard i n' l' j => exact h.barH_comm_bard l φ i l' _ + | u i n' l' j => exact h.barH_comm_u l φ i l' _ + | baru i n' l' j => exact h.barH_comm_baru l φ i l' _ + | Q i n' l' j => exact h.barH_comm_Q l φ i l' _ + | barQ i n' l' j => exact h.barH_comm_barQ l φ i l' _ + | L i n' l' j => exact h.barH_comm_L l φ i l' _ + | barL i n' l' j => exact h.barH_comm_barL l φ i l' _ + | e i n' l' j => exact h.barH_comm_e l φ i l' _ + | bare i n' l' j => exact h.barH_comm_bare l φ i l' _ + +/-- A covariant generator of even mass weight is bosonic: its value commutes with + the value of every covariant generator. -/ +lemma commute_generatorVal_of_even {g : Generators} (hg : g.weight % 2 = 0) + (g' : Generators) : Commute (h.generatorVal g) (h.generatorVal g') := by + cases g with + | H n l j => exact h.commute_H_generatorVal l _ g' + | barH n l j => exact h.commute_barH_generatorVal l _ g' + | F n l μ ν j => exact h.commute_F_generatorVal l μ ν _ g' + | d i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | bard i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | u i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | baru i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | Q i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | barQ i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | L i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | barL i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | e i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | bare i n l j => exact absurd hg (by simp only [Generators.weight]; omega) + +/-- Fermionic generator values anticommute: the values of two covariant generators + of odd mass weight exchange with a sign. -/ +lemma generatorVal_anticomm_of_odd_of_odd {g g' : Generators} + (hg : g.weight % 2 = 1) (hg' : g'.weight % 2 = 1) : + h.generatorVal g * h.generatorVal g' + = -(h.generatorVal g' * h.generatorVal g) := by + cases g with + | H n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | barH n l j => exact absurd hg (by simp only [Generators.weight]; omega) + | F n l μ ν j => exact absurd hg (by simp only [Generators.weight]; omega) + | d i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_d i i' l l' _ _ + | bard i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_bard i i' l l' _ _ + | u i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_u i i' l l' _ _ + | baru i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_baru i i' l l' _ _ + | Q i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_Q i i' l l' _ _ + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.d_anticomm_bare i i' l l' _ _ + | bard i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_bard i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_bard i i' l l' _ _ + | u i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_u i i' l l' _ _ + | baru i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_baru i i' l l' _ _ + | Q i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_Q i i' l l' _ _ + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.bard_anticomm_bare i i' l l' _ _ + | u i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_u i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_u i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_u i i' l l' _ _ + | baru i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_baru i i' l l' _ _ + | Q i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_Q i i' l l' _ _ + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.u_anticomm_bare i i' l l' _ _ + | baru i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_baru i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_baru i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_baru i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_baru i i' l l' _ _ + | Q i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_Q i i' l l' _ _ + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.baru_anticomm_bare i i' l l' _ _ + | Q i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_Q i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_Q i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_Q i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_Q i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_Q i i' l l' _ _ + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.Q_anticomm_bare i i' l l' _ _ + | barQ i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_barQ i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_barQ i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_barQ i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_barQ i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + rw [h.Q_anticomm_barQ i' i l' l, neg_neg] + | barQ i' n' l' j' => + simp only [generatorVal] + exact h.barQ_anticomm_barQ i i' l l' _ _ + | L i' n' l' j' => + simp only [generatorVal] + exact h.barQ_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.barQ_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.barQ_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.barQ_anticomm_bare i i' l l' _ _ + | L i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_L i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_L i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_L i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_L i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + rw [h.Q_anticomm_L i' i l' l, neg_neg] + | barQ i' n' l' j' => + simp only [generatorVal] + rw [h.barQ_anticomm_L i' i l' l, neg_neg] + | L i' n' l' j' => + simp only [generatorVal] + exact h.L_anticomm_L i i' l l' _ _ + | barL i' n' l' j' => + simp only [generatorVal] + exact h.L_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.L_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.L_anticomm_bare i i' l l' _ _ + | barL i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_barL i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_barL i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_barL i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_barL i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + rw [h.Q_anticomm_barL i' i l' l, neg_neg] + | barQ i' n' l' j' => + simp only [generatorVal] + rw [h.barQ_anticomm_barL i' i l' l, neg_neg] + | L i' n' l' j' => + simp only [generatorVal] + rw [h.L_anticomm_barL i' i l' l, neg_neg] + | barL i' n' l' j' => + simp only [generatorVal] + exact h.barL_anticomm_barL i i' l l' _ _ + | e i' n' l' j' => + simp only [generatorVal] + exact h.barL_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.barL_anticomm_bare i i' l l' _ _ + | e i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_e i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_e i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_e i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_e i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + rw [h.Q_anticomm_e i' i l' l, neg_neg] + | barQ i' n' l' j' => + simp only [generatorVal] + rw [h.barQ_anticomm_e i' i l' l, neg_neg] + | L i' n' l' j' => + simp only [generatorVal] + rw [h.L_anticomm_e i' i l' l, neg_neg] + | barL i' n' l' j' => + simp only [generatorVal] + rw [h.barL_anticomm_e i' i l' l, neg_neg] + | e i' n' l' j' => + simp only [generatorVal] + exact h.e_anticomm_e i i' l l' _ _ + | bare i' n' l' j' => + simp only [generatorVal] + exact h.e_anticomm_bare i i' l l' _ _ + | bare i n l j => + cases g' with + | H n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | barH n' l' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | F n' l' μ' ν' j' => exact absurd hg' (by simp only [Generators.weight]; omega) + | d i' n' l' j' => + simp only [generatorVal] + rw [h.d_anticomm_bare i' i l' l, neg_neg] + | bard i' n' l' j' => + simp only [generatorVal] + rw [h.bard_anticomm_bare i' i l' l, neg_neg] + | u i' n' l' j' => + simp only [generatorVal] + rw [h.u_anticomm_bare i' i l' l, neg_neg] + | baru i' n' l' j' => + simp only [generatorVal] + rw [h.baru_anticomm_bare i' i l' l, neg_neg] + | Q i' n' l' j' => + simp only [generatorVal] + rw [h.Q_anticomm_bare i' i l' l, neg_neg] + | barQ i' n' l' j' => + simp only [generatorVal] + rw [h.barQ_anticomm_bare i' i l' l, neg_neg] + | L i' n' l' j' => + simp only [generatorVal] + rw [h.L_anticomm_bare i' i l' l, neg_neg] + | barL i' n' l' j' => + simp only [generatorVal] + rw [h.barL_anticomm_bare i' i l' l, neg_neg] + | e i' n' l' j' => + simp only [generatorVal] + rw [h.e_anticomm_bare i' i l' l, neg_neg] + | bare i' n' l' j' => + simp only [generatorVal] + exact h.bare_anticomm_bare i i' l l' _ _ + +/-- Two covariant generators exchange up to the sign determined by their mass + weights: the weight is odd exactly on the fermionic generators, so the sign is + `-1` precisely when both generators are fermionic. -/ +lemma generatorVal_mul_generatorVal (g g' : Generators) : + h.generatorVal g * h.generatorVal g' = + ((-1 : ℂ) ^ (g.weight * g'.weight)) • (h.generatorVal g' * h.generatorVal g) := by + rcases Nat.even_or_odd g.weight with hg | hg + · rw [Even.neg_one_pow (hg.mul_right _), one_smul] + exact h.commute_generatorVal_of_even (Nat.even_iff.mp hg) g' + · rcases Nat.even_or_odd g'.weight with hg' | hg' + · rw [Even.neg_one_pow (hg'.mul_left _), one_smul] + exact (h.commute_generatorVal_of_even (Nat.even_iff.mp hg') g).symm + · rw [Odd.neg_one_pow (hg.mul hg'), neg_one_smul] + exact h.generatorVal_anticomm_of_odd_of_odd (Nat.odd_iff.mp hg) (Nat.odd_iff.mp hg') + +/-- A generator value moves past a word of generators up to the sign of the + product of the weights. -/ +lemma generatorVal_mul_list_prod (g : Generators) (gl : List Generators) : + h.generatorVal g * (gl.map h.generatorVal).prod = + ((-1 : ℂ) ^ (g.weight * (gl.map Generators.weight).sum)) • + ((gl.map h.generatorVal).prod * h.generatorVal g) := by + induction gl with + | nil => simp + | cons g' t ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons] + calc h.generatorVal g * (h.generatorVal g' * (t.map h.generatorVal).prod) + = (h.generatorVal g * h.generatorVal g') * (t.map h.generatorVal).prod := by + rw [mul_assoc] + _ = ((-1 : ℂ) ^ (g.weight * g'.weight)) • + (h.generatorVal g' * (h.generatorVal g * (t.map h.generatorVal).prod)) := by + rw [h.generatorVal_mul_generatorVal g g', smul_mul_assoc, mul_assoc] + _ = ((-1 : ℂ) ^ (g.weight * g'.weight)) • (h.generatorVal g' * + (((-1 : ℂ) ^ (g.weight * (t.map Generators.weight).sum)) • + ((t.map h.generatorVal).prod * h.generatorVal g))) := by rw [ih] + _ = ((-1 : ℂ) ^ (g.weight * (g'.weight + (t.map Generators.weight).sum))) • + ((h.generatorVal g' * (t.map h.generatorVal).prod) * h.generatorVal g) := by + rw [mul_smul_comm, smul_smul, ← pow_add, ← mul_add, ← mul_assoc] + +/-- Two words of covariant generators exchange up to the sign of the product of + their total weights. -/ +lemma list_prod_mul_list_prod (gl gl' : List Generators) : + (gl.map h.generatorVal).prod * (gl'.map h.generatorVal).prod = + ((-1 : ℂ) ^ ((gl.map Generators.weight).sum * (gl'.map Generators.weight).sum)) • + ((gl'.map h.generatorVal).prod * (gl.map h.generatorVal).prod) := by + induction gl with + | nil => simp + | cons g t ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons] + calc (h.generatorVal g * (t.map h.generatorVal).prod) * (gl'.map h.generatorVal).prod + = h.generatorVal g * ((t.map h.generatorVal).prod * (gl'.map h.generatorVal).prod) := by + rw [mul_assoc] + _ = ((-1 : ℂ) ^ ((t.map Generators.weight).sum * (gl'.map Generators.weight).sum)) • + ((h.generatorVal g * (gl'.map h.generatorVal).prod) * (t.map h.generatorVal).prod) := by + rw [ih, mul_smul_comm, ← mul_assoc] + _ = ((-1 : ℂ) ^ ((t.map Generators.weight).sum * (gl'.map Generators.weight).sum)) • + ((((-1 : ℂ) ^ (g.weight * (gl'.map Generators.weight).sum)) • + ((gl'.map h.generatorVal).prod * h.generatorVal g)) * (t.map h.generatorVal).prod) := by + rw [h.generatorVal_mul_list_prod g gl'] + _ = ((-1 : ℂ) ^ ((g.weight + (t.map Generators.weight).sum) * + (gl'.map Generators.weight).sum)) • + ((gl'.map h.generatorVal).prod * (h.generatorVal g * (t.map h.generatorVal).prod)) := by + rw [smul_mul_assoc, smul_smul, ← pow_add, mul_assoc, + show (t.map Generators.weight).sum * (gl'.map Generators.weight).sum + + g.weight * (gl'.map Generators.weight).sum + = (g.weight + (t.map Generators.weight).sum) * + (gl'.map Generators.weight).sum from by ring] + + +/-! + +## The different sectors of the Standard Model + +Each covariant generator belongs to one of three classes — gauge, Higgs or fermion — +and a word in the generators realises a set of classes. The sector of a class set `S` +is spanned by the words realising exactly `S`. It contains no non-zero scalar, since +the empty word realises no class at all, and it is closed under multiplication because +`S ∪ S = S`: it is a non-unital subalgebra. The seven non-empty class sets give the +seven sectors below. + +-/ + +/-- The three classes of covariant generator. -/ +inductive GeneratorClass where + /-- The gauge class: the field-strength towers. -/ + | gauge : GeneratorClass + /-- The Higgs class: the Higgs towers and their conjugates. -/ + | higgs : GeneratorClass + /-- The fermion class: the fermion towers and their conjugates. -/ + | fermion : GeneratorClass +deriving DecidableEq + +/-- The class of a covariant generator. -/ +def Generators.kind : Generators → GeneratorClass + | .F _ _ _ _ _ => .gauge + | .H _ _ _ => .higgs + | .barH _ _ _ => .higgs + | _ => .fermion + +@[simp] +lemma Generators.isGaugeField_iff_kind (g : Generators) : + g.IsGaugeField ↔ g.kind = .gauge := by + cases g <;> simp [Generators.IsGaugeField, Generators.kind] + +@[simp] +lemma Generators.isHiggs_iff_kind (g : Generators) : g.IsHiggs ↔ g.kind = .higgs := by + cases g <;> simp [Generators.IsHiggs, Generators.kind] + +@[simp] +lemma Generators.isFermionic_iff_kind (g : Generators) : + g.IsFermionic ↔ g.kind = .fermion := by + cases g <;> simp [Generators.IsFermionic, Generators.kind] + +/-- The classes realised by a word in the covariant generators. -/ +def wordClasses (gl : List Generators) : Finset GeneratorClass := + (gl.map Generators.kind).toFinset + +@[simp] +lemma wordClasses_nil : wordClasses [] = ∅ := by simp [wordClasses] + +/-- Concatenating words unions the classes they realise. -/ +lemma wordClasses_append (gl gl' : List Generators) : + wordClasses (gl ++ gl') = wordClasses gl ∪ wordClasses gl' := by + rw [wordClasses, wordClasses, wordClasses, List.map_append, List.toFinset_append] + +/-- Prepending a generator inserts its class. -/ +lemma wordClasses_cons (a : Generators) (gl : List Generators) : + wordClasses (a :: gl) = insert a.kind (wordClasses gl) := by + rw [wordClasses, wordClasses, List.map_cons, List.toFinset_cons] + +/-- The span of the words in the covariant generators realising exactly the classes + `S`. -/ +def sectorSubmodule (S : Finset GeneratorClass) : Submodule ℂ B := + Submodule.span ℂ + {x | ∃ gl : List Generators, wordClasses gl = S ∧ (gl.map h.generatorVal).prod = x} + +/-- Multiplication carries the class spans of `S` and `T` into that of `S ∪ T`. -/ +lemma mul_mem_sectorSubmodule {S T : Finset GeneratorClass} {x y : B} + (hx : x ∈ h.sectorSubmodule S) (hy : y ∈ h.sectorSubmodule T) : + x * y ∈ h.sectorSubmodule (S ∪ T) := by + induction hx using Submodule.span_induction with + | mem x hxw => + obtain ⟨gl, hgl, rfl⟩ := hxw + induction hy using Submodule.span_induction with + | mem y hyw => + obtain ⟨gl', hgl', rfl⟩ := hyw + refine Submodule.subset_span ⟨gl ++ gl', ?_, ?_⟩ + · rw [wordClasses_append, hgl, hgl'] + · rw [List.map_append, List.prod_append] + | zero => rw [mul_zero]; exact Submodule.zero_mem _ + | add a b ha hb iha ihb => rw [mul_add]; exact Submodule.add_mem _ iha ihb + | smul c a ha iha => rw [mul_smul_comm]; exact Submodule.smul_mem _ _ iha + | zero => rw [zero_mul]; exact Submodule.zero_mem _ + | add a b ha hb iha ihb => rw [add_mul]; exact Submodule.add_mem _ iha ihb + | smul c a ha iha => rw [smul_mul_assoc]; exact Submodule.smul_mem _ _ iha + +/-- The sector realising exactly the classes `S`: the span of the words whose + generators realise `S`. It is a non-unital subalgebra — closed under multiplication + since `S ∪ S = S`, but containing no non-zero scalar, since the empty word realises + no class. -/ +def sector (S : Finset GeneratorClass) : NonUnitalSubalgebra ℂ B := + (h.sectorSubmodule S).toNonUnitalSubalgebra fun x y hx hy => by + have hxy := h.mul_mem_sectorSubmodule hx hy + rwa [Finset.union_self] at hxy + +@[simp] +lemma mem_sector {S : Finset GeneratorClass} {x : B} : + x ∈ h.sector S ↔ x ∈ h.sectorSubmodule S := Iff.rfl + +/-- A word lies in the sector of the classes it realises. -/ +lemma list_prod_mem_sector (gl : List Generators) : + (gl.map h.generatorVal).prod ∈ h.sector (wordClasses gl) := + Submodule.subset_span ⟨gl, rfl, rfl⟩ + +/-- Multiplication carries the sectors of `S` and `T` into the sector of `S ∪ T`. -/ +lemma mul_mem_sector {S T : Finset GeneratorClass} {x y : B} + (hx : x ∈ h.sector S) (hy : y ∈ h.sector T) : x * y ∈ h.sector (S ∪ T) := + h.mul_mem_sectorSubmodule hx hy + +/-- Every sector sits inside the field algebra. -/ +lemma mem_fieldAlgebra_of_mem_sector {S : Finset GeneratorClass} {x : B} + (hx : x ∈ h.sector S) : x ∈ h.fieldAlgebra := by + rw [mem_sector, sectorSubmodule] at hx + induction hx using Submodule.span_induction with + | mem y hy => + obtain ⟨gl, -, rfl⟩ := hy + refine Subalgebra.list_prod_mem _ fun z hz => ?_ + obtain ⟨g, -, rfl⟩ := List.mem_map.mp hz + exact h.generatorVal_mem_fieldAlgebra g + | zero => exact Subalgebra.zero_mem _ + | add a b ha hb iha ihb => exact Subalgebra.add_mem _ iha ihb + | smul c a ha iha => exact Subalgebra.smul_mem _ iha c + +/-- **The sectors exhaust the field algebra**: every element of the field algebra is a + sum of elements of the sectors, since every word realises exactly one class set. The + unit is supplied by `sector ∅`, the sector of the empty word, so the join is the + whole of `fieldAlgebra` — read as a non-unital subalgebra, the two sides having + otherwise different types. -/ +lemma fieldAlgebra_eq_iSup_sector : + h.fieldAlgebra.toNonUnitalSubalgebra = ⨆ S : Finset GeneratorClass, h.sector S := by + refine le_antisymm ?_ (iSup_le fun S => ?_) + · intro x hx + rw [Subalgebra.mem_toNonUnitalSubalgebra, h.fieldAlgebra_eq_adjoin_range, + ← Subalgebra.mem_toSubmodule, Algebra.adjoin_eq_span] at hx + induction hx using Submodule.span_induction with + | mem y hy => + obtain ⟨l₀, hl₀, rfl⟩ := Submonoid.exists_list_of_mem_closure hy + obtain ⟨gl, rfl⟩ := h.exists_list_map_eq l₀ hl₀ + exact le_iSup (fun S : Finset GeneratorClass => h.sector S) (wordClasses gl) + (h.list_prod_mem_sector gl) + | zero => exact zero_mem _ + | add a b ha hb iha ihb => exact add_mem iha ihb + | smul c a ha iha => exact SMulMemClass.smul_mem c iha + · intro x hx + exact Subalgebra.mem_toNonUnitalSubalgebra.mpr (h.mem_fieldAlgebra_of_mem_sector hx) + + +/-! + +### The sectors are preserved by the gauge and Lorentz actions + +Both actions carry a covariant tower into combinations of towers of the same +species, hence each generator into the sector of its own class, hence — word by +word — each sector into itself. + +-/ + +/-- Any Higgs tower symbol lies in the Higgs sector. -/ +lemma H_mem_sector {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) : H l φ ∈ h.sector {GeneratorClass.higgs} := by + rw [← HiggsVec.orthonormBasis.toBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.H n l j] + +/-- Any conjugate-Higgs tower symbol lies in the Higgs sector. -/ +lemma barH_mem_sector {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + barH l φ ∈ h.sector {GeneratorClass.higgs} := by + rw [← HiggsVec.orthonormBasis.toBasis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.barH n l j] + +/-- Any field-strength tower symbol lies in the gauge sector. -/ +lemma F_mem_sector {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) (μ ν : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : F l μ ν φ ∈ h.sector {GeneratorClass.gauge} := by + rw [← GaugeAlgebra.stdBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => ?_ + rw [← algebraMap_smul ℂ (φ (GaugeAlgebra.stdBasis j))] + refine SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.F n l μ ν j] + +/-- Any `d` tower symbol lies in the fermion sector. -/ +lemma d_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ DownSinglet) : d i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← DownSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.d i n l j] + +/-- Any `bard` tower symbol lies in the fermion sector. -/ +lemma bard_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : bard i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← DownSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.bard i n l j] + +/-- Any `u` tower symbol lies in the fermion sector. -/ +lemma u_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ UpSinglet) : u i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← UpSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.u i n l j] + +/-- Any `baru` tower symbol lies in the fermion sector. -/ +lemma baru_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : baru i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← UpSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.baru i n l j] + +/-- Any `Q` tower symbol lies in the fermion sector. -/ +lemma Q_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ QuarkDoublet) : Q i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← QuarkDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.Q i n l j] + +/-- Any `barQ` tower symbol lies in the fermion sector. -/ +lemma barQ_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : barQ i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← QuarkDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.barQ i n l j] + +/-- Any `L` tower symbol lies in the fermion sector. -/ +lemma L_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonDoublet) : L i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← LeptonDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.L i n l j] + +/-- Any `barL` tower symbol lies in the fermion sector. -/ +lemma barL_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : barL i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← LeptonDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.barL i n l j] + +/-- Any `e` tower symbol lies in the fermion sector. -/ +lemma e_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonSinglet) : e i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← LeptonSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.e i n l j] + +/-- Any `bare` tower symbol lies in the fermion sector. -/ +lemma bare_mem_sector (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : bare i l φ ∈ h.sector {GeneratorClass.fermion} := by + rw [← LeptonSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine sum_mem fun j _ => SMulMemClass.smul_mem _ ?_ + simpa [generatorVal, wordClasses, Generators.kind] using + h.list_prod_mem_sector [Generators.bare i n l j] + +/-- The gauge action carries a covariant generator into the sector of its class. -/ +lemma repGauge_generatorVal_mem_sector (g : GaugeGroupI) (a : Generators) : + repGauge g (h.generatorVal a) ∈ h.sector {a.kind} := by + cases a with + | H n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_H g l _] + exact h.H_mem_sector l _ + | barH n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_barH g l _] + exact h.barH_mem_sector l _ + | F n l μ ν j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_F g l μ ν _] + exact h.F_mem_sector l μ ν _ + | d i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_d g i l _] + exact h.d_mem_sector i l _ + | bard i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_bard g i l _] + exact h.bard_mem_sector i l _ + | u i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_u g i l _] + exact h.u_mem_sector i l _ + | baru i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_baru g i l _] + exact h.baru_mem_sector i l _ + | Q i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_Q g i l _] + exact h.Q_mem_sector i l _ + | barQ i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_barQ g i l _] + exact h.barQ_mem_sector i l _ + | L i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_L g i l _] + exact h.L_mem_sector i l _ + | barL i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_barL g i l _] + exact h.barL_mem_sector i l _ + | e i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_e g i l _] + exact h.e_mem_sector i l _ + | bare i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repGauge_bare g i l _] + exact h.bare_mem_sector i l _ + +/-- The Lorentz action carries a covariant generator into the sector of its + class. -/ +lemma repLorentz_generatorVal_mem_sector (Λ : SL(2,ℂ)) (a : Generators) : + repLorentz Λ (h.generatorVal a) ∈ h.sector {a.kind} := by + cases a with + | H n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_H Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.H_mem_sector p _) + | barH n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_barH Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.barH_mem_sector p _) + | F n l μ ν j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_F Λ n l μ ν _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ + (sum_mem fun a _ => SMulMemClass.smul_mem _ + (sum_mem fun b _ => SMulMemClass.smul_mem _ (h.F_mem_sector p a b _))) + | d i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_d i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.d_mem_sector i p _) + | bard i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_bard i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.bard_mem_sector i p _) + | u i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_u i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.u_mem_sector i p _) + | baru i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_baru i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.baru_mem_sector i p _) + | Q i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_Q i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.Q_mem_sector i p _) + | barQ i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_barQ i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.barQ_mem_sector i p _) + | L i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_L i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.L_mem_sector i p _) + | barL i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_barL i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.barL_mem_sector i p _) + | e i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_e i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.e_mem_sector i p _) + | bare i n l j => + simp only [generatorVal, Generators.kind] + rw [h.repLorentz_bare i Λ n l _] + exact sum_mem fun p _ => SMulMemClass.smul_mem _ (h.bare_mem_sector i p _) + +/-- The action `repGauge` preserves every sector. -/ +lemma repGauge_mem_sector {S : Finset GeneratorClass} {x : B} (g : GaugeGroupI) + (hx : x ∈ h.sector S) : repGauge g x ∈ h.sector S := by + rw [mem_sector, sectorSubmodule] at hx + induction hx using Submodule.span_induction with + | mem y hy => + obtain ⟨gl, hgl, rfl⟩ := hy + subst hgl + induction gl with + | nil => + simp only [List.map_nil, List.prod_nil] + rw [h.repGauge_one g] + simpa using h.list_prod_mem_sector ([] : List Generators) + | cons a t ih => + simp only [List.map_cons, List.prod_cons] + rw [h.repGauge_mul g, wordClasses_cons, ← Finset.singleton_union] + exact h.mul_mem_sector (h.repGauge_generatorVal_mem_sector g a) ih + | zero => rw [map_zero]; exact zero_mem _ + | add a b ha hb iha ihb => rw [map_add]; exact add_mem iha ihb + | smul c a ha iha => rw [map_smul]; exact SMulMemClass.smul_mem _ iha + +/-- The action `repLorentz` preserves every sector. -/ +lemma repLorentz_mem_sector {S : Finset GeneratorClass} {x : B} (Λ : SL(2,ℂ)) + (hx : x ∈ h.sector S) : repLorentz Λ x ∈ h.sector S := by + rw [mem_sector, sectorSubmodule] at hx + induction hx using Submodule.span_induction with + | mem y hy => + obtain ⟨gl, hgl, rfl⟩ := hy + subst hgl + induction gl with + | nil => + simp only [List.map_nil, List.prod_nil] + rw [h.repLorentz_one Λ] + simpa using h.list_prod_mem_sector ([] : List Generators) + | cons a t ih => + simp only [List.map_cons, List.prod_cons] + rw [h.repLorentz_mul Λ, wordClasses_cons, ← Finset.singleton_union] + exact h.mul_mem_sector (h.repLorentz_generatorVal_mem_sector Λ a) ih + | zero => rw [map_zero]; exact zero_mem _ + | add a b ha hb iha ihb => rw [map_add]; exact add_mem iha ihb + | smul c a ha iha => rw [map_smul]; exact SMulMemClass.smul_mem _ iha + +/-! + +### Decomposition lemma + +-/ +end IsCovStandardModel + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight.lean b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight.lean new file mode 100644 index 000000000..713416bc3 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsCovStandardModel/MassWeight.lean @@ -0,0 +1,571 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.IsCovStandardModel.Generators +/-! +# The mass-weight grading of the field algebra + +The elements of the field algebra of a given mass weight form a submodule, which is +exactly the span of the words in the covariant generators of that total weight +(`massWeightSubmodule_eq_span`). Weight-homogeneous elements supercommute, +the gauge and Lorentz actions preserve the weight, and consequently an invariant +element decomposing into components of pairwise distinct weights has invariant +components. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + + +namespace IsCovStandardModel + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repGauge : Representation ℂ GaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + {H : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B} + {barH : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B} + {F : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {d : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B} + {bard : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B} + {u : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B} + {baru : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B} + {Q : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B} + {barQ : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B} + {L : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B} + {barL : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B} + {e : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B} + {bare : {n : ℕ} → Fin 3 → (Fin n → Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B} + (h : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) + +/-! + +## A. The mass-weight submodules + +-/ + + + +/-- All elements of the field algebra of mass weight exactly `n`: the intersection of + the algebra generated by the covariant fields with the part on which + `massWeightPoly` is the monomial `X ^ n`. -/ +noncomputable def massWeightSubmodule + (h : IsCovStandardModel B repGauge repLorentz massWeightPoly H barH F + d bard u baru Q barQ L barL e bare) (n : ℕ) : Submodule ℂ B := + (h.fieldAlgebra).toSubmodule + ⊓ LinearMap.ker (massWeightPoly.toLinearMap + - (Polynomial.monomial n : B →ₗ[B] Polynomial B).restrictScalars ℂ) + +lemma massWeightPoly_of_mem_massWeightSubmodule {n : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule n) : + massWeightPoly x = Polynomial.monomial n x := by + rw [massWeightSubmodule, Submodule.mem_inf] at hx + rcases hx with ⟨-, hx'⟩ + rw [LinearMap.mem_ker] at hx' + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] at hx' + exact hx' + +lemma mem_fieldAlgebra_of_mem_massWeightSubmodule {n : ℕ} {x : B} + (hx : x ∈ h.massWeightSubmodule n) : x ∈ h.fieldAlgebra := by + rw [massWeightSubmodule, Submodule.mem_inf] at hx + exact hx.1 + +/-- Membership in a mass-weight submodule: an element of the field algebra which + `massWeightPoly` sends to the monomial of that weight. -/ +lemma mem_massWeightSubmodule_of {n : ℕ} {x : B} (hmem : x ∈ h.fieldAlgebra) + (hpoly : massWeightPoly x = Polynomial.monomial n x) : + x ∈ h.massWeightSubmodule n := by + rw [massWeightSubmodule] + refine Submodule.mem_inf.mpr ⟨hmem, ?_⟩ + rw [LinearMap.mem_ker] + simp only [LinearMap.sub_apply, AlgHom.toLinearMap_apply, LinearMap.coe_restrictScalars, + sub_eq_zero] + exact hpoly +/-! + +## B. The weight grading of the field algebra + +-/ + +/-- A word in the covariant generators lies in the mass-weight submodule of its total + weight. -/ +lemma list_prod_mem_massWeightSubmodule {w : ℕ} {gl : List Generators} + (hw : (gl.map Generators.weight).sum = w) : + (gl.map h.generatorVal).prod ∈ h.massWeightSubmodule w := + h.mem_massWeightSubmodule_of + (Subalgebra.list_prod_mem _ fun y hy => by + obtain ⟨g, -, rfl⟩ := List.mem_map.mp hy + exact h.generatorVal_mem_fieldAlgebra g) + (by rw [h.massWeightPoly_generatorVal_list_prod, hw]) + +/-- Reading off the `X ^ w` coefficient of `massWeightPoly` sends the field algebra + into the span of the words of total weight `w` — the projection onto the weight-`w` + component, with no independence argument needed. -/ +lemma coeff_massWeightPoly_mem_span (w : ℕ) {x : B} + (hx : x ∈ h.fieldAlgebra) : + (massWeightPoly x).coeff w ∈ Submodule.span ℂ + {y | ∃ gl : List Generators, + (gl.map Generators.weight).sum = w ∧ (gl.map h.generatorVal).prod = y} := by + rw [h.fieldAlgebra_eq_adjoin_range, ← Subalgebra.mem_toSubmodule, + Algebra.adjoin_eq_span] at hx + induction hx using Submodule.span_induction with + | mem y hy => + obtain ⟨l₀, hl₀, rfl⟩ := Submonoid.exists_list_of_mem_closure hy + obtain ⟨gl, rfl⟩ := h.exists_list_map_eq l₀ hl₀ + rw [h.massWeightPoly_generatorVal_list_prod, Polynomial.coeff_monomial] + by_cases hw : (gl.map Generators.weight).sum = w + · rw [if_pos hw] + exact Submodule.subset_span ⟨gl, hw, rfl⟩ + · rw [if_neg hw] + exact Submodule.zero_mem _ + | zero => + rw [map_zero, Polynomial.coeff_zero] + exact Submodule.zero_mem _ + | add a b ha hb iha ihb => + rw [map_add, Polynomial.coeff_add] + exact Submodule.add_mem _ iha ihb + | smul c a ha iha => + rw [map_smul, Polynomial.coeff_smul] + exact Submodule.smul_mem _ _ iha + +/-- **The weight grading of the field algebra.** The submodule of elements of the + field algebra of mass weight `w` is exactly the span of the words in the covariant + basis generators of total weight `w`. -/ +theorem massWeightSubmodule_eq_span (w : ℕ) : + h.massWeightSubmodule w = Submodule.span ℂ + {x | ∃ gl : List Generators, + (gl.map Generators.weight).sum = w ∧ (gl.map h.generatorVal).prod = x} := by + refine le_antisymm (fun x hx => ?_) (Submodule.span_le.mpr ?_) + · have h1 := h.massWeightPoly_of_mem_massWeightSubmodule hx + have h2 := h.coeff_massWeightPoly_mem_span w + (h.mem_fieldAlgebra_of_mem_massWeightSubmodule hx) + rwa [h1, Polynomial.coeff_monomial, if_pos rfl] at h2 + · rintro x ⟨gl, hw, rfl⟩ + exact h.list_prod_mem_massWeightSubmodule hw +/-! + +## C. Supercommutativity of weight-homogeneous elements + +-/ + +/-- Weight-homogeneous elements of the field algebra supercommute: elements of the + mass-weight submodules of weights `w` and `w'` exchange up to the sign + `(-1) ^ (w * w')` — fermion parity is the parity of the mass weight. -/ +theorem mul_eq_smul_mul_of_mem_massWeightSubmodule {w w' : ℕ} {x y : B} + (hx : x ∈ h.massWeightSubmodule w) (hy : y ∈ h.massWeightSubmodule w') : + x * y = ((-1 : ℂ) ^ (w * w')) • (y * x) := by + rw [h.massWeightSubmodule_eq_span] at hx hy + induction hx using Submodule.span_induction with + | mem x hxw => + obtain ⟨gl, hglw, rfl⟩ := hxw + induction hy using Submodule.span_induction with + | mem y hyw => + obtain ⟨gl', hgl'w, rfl⟩ := hyw + rw [← hglw, ← hgl'w] + exact h.list_prod_mul_list_prod gl gl' + | zero => simp + | add a b ha hb iha ihb => rw [mul_add, iha, ihb, add_mul, smul_add] + | smul c a ha iha => rw [mul_smul_comm, iha, smul_comm, smul_mul_assoc] + | zero => simp + | add a b ha hb iha ihb => rw [add_mul, iha, ihb, mul_add, smul_add] + | smul c a ha iha => rw [smul_mul_assoc, iha, smul_comm, mul_smul_comm] + +/-- Weight-homogeneous elements of the field algebra commute up to a scalar. -/ +lemma exists_smul_mul_comm_of_mem_massWeightSubmodule {w w' : ℕ} {x y : B} + (hx : x ∈ h.massWeightSubmodule w) (hy : y ∈ h.massWeightSubmodule w') : + ∃ c : ℂ, x * y = c • (y * x) := + ⟨_, h.mul_eq_smul_mul_of_mem_massWeightSubmodule hx hy⟩ + +/-- Reordering a product of two weight-homogeneous elements does not change its + span. -/ +lemma span_mul_comm_of_mem_massWeightSubmodule {w w' : ℕ} {x y : B} + (hx : x ∈ h.massWeightSubmodule w) (hy : y ∈ h.massWeightSubmodule w') : + ℂ ∙ (x * y) = ℂ ∙ (y * x) := by + rw [h.mul_eq_smul_mul_of_mem_massWeightSubmodule hx hy] + exact Submodule.span_singleton_smul_eq ((isUnit_one.neg).pow _) _ + +lemma d_supercommute_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} {l : Fin n → Fin 1 ⊕ Fin 3} + (φ : Module.Dual ℂ DownSinglet) {w : ℕ} (x : B) (hx : x ∈ h.massWeightSubmodule w) : + d i l φ * x = ((-1 : ℂ) ^ w) • (x * d i l φ) := by + sorry +/-! + +## D. Invariance of the weight components + +The gauge and Lorentz actions preserve the mass weight: they carry each covariant +tower into combinations of towers of the same derivative order. The weight +components of the field algebra are independent, so an invariant element that is +a sum of components of pairwise distinct weights has invariant components. + +-/ + +/-- The mass-weight submodules are multiplicative: weights add under multiplication. -/ +lemma mul_mem_massWeightSubmodule {w w2 : ℕ} {x y : B} + (hx : x ∈ h.massWeightSubmodule w) (hy : y ∈ h.massWeightSubmodule w2) : + x * y ∈ h.massWeightSubmodule (w + w2) := + h.mem_massWeightSubmodule_of + (mul_mem (h.mem_fieldAlgebra_of_mem_massWeightSubmodule hx) + (h.mem_fieldAlgebra_of_mem_massWeightSubmodule hy)) + (by rw [map_mul, h.massWeightPoly_of_mem_massWeightSubmodule hx, + h.massWeightPoly_of_mem_massWeightSubmodule hy, Polynomial.monomial_mul_monomial]) + +/-- Any Higgs tower symbol lies in the mass-weight submodule of its weight. -/ +lemma H_mem_massWeightSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ HiggsVec) : H l φ ∈ h.massWeightSubmodule (2 * (1 + n)) := by + rw [← HiggsVec.orthonormBasis.toBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.H n l j]) (by simp [Generators.weight]) + +/-- Any conjugate-Higgs tower symbol lies in the mass-weight submodule of its weight. -/ +lemma barH_mem_massWeightSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule HiggsVec)) : + barH l φ ∈ h.massWeightSubmodule (2 * (1 + n)) := by + rw [← HiggsVec.orthonormBasis.toBasis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.barH n l j]) (by simp [Generators.weight]) + +/-- Any field-strength tower symbol lies in the mass-weight submodule of its weight. -/ +lemma F_mem_massWeightSubmodule {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + F l μ ν φ ∈ h.massWeightSubmodule (2 * (2 + n)) := by + rw [← GaugeAlgebra.stdBasis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => ?_ + rw [← algebraMap_smul ℂ (φ (GaugeAlgebra.stdBasis j))] + refine Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.F n l μ ν j]) (by simp [Generators.weight]) + +/-- Any `d` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma d_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ DownSinglet) : d i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← DownSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.d i n l j]) (by simp [Generators.weight]) + +/-- Any `bard` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma bard_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule DownSinglet)) : bard i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← DownSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.bard i n l j]) (by simp [Generators.weight]) + +/-- Any `u` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma u_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ UpSinglet) : u i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← UpSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.u i n l j]) (by simp [Generators.weight]) + +/-- Any `baru` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma baru_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule UpSinglet)) : baru i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← UpSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.baru i n l j]) (by simp [Generators.weight]) + +/-- Any `Q` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma Q_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ QuarkDoublet) : Q i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← QuarkDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.Q i n l j]) (by simp [Generators.weight]) + +/-- Any `barQ` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma barQ_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)) : barQ i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← QuarkDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.barQ i n l j]) (by simp [Generators.weight]) + +/-- Any `L` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma L_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonDoublet) : L i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← LeptonDoublet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.L i n l j]) (by simp [Generators.weight]) + +/-- Any `barL` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma barL_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)) : barL i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← LeptonDoublet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.barL i n l j]) (by simp [Generators.weight]) + +/-- Any `e` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma e_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ LeptonSinglet) : e i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← LeptonSinglet.basis.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.e i n l j]) (by simp [Generators.weight]) + +/-- Any `bare` tower symbol lies in the mass-weight submodule of its weight. -/ +lemma bare_mem_massWeightSubmodule (i : Fin 3) {n : ℕ} (l : Fin n → Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)) : bare i l φ ∈ h.massWeightSubmodule (3 + 2 * n) := by + rw [← LeptonSinglet.basis.conj.sum_dual_apply_smul_coord φ] + simp only [map_sum, map_smul] + refine Submodule.sum_mem _ fun j _ => Submodule.smul_mem _ _ ?_ + simpa [generatorVal] using h.list_prod_mem_massWeightSubmodule + (gl := [Generators.bare i n l j]) (by simp [Generators.weight]) + +/-- The gauge action carries a covariant generator into the mass-weight submodule + of its weight. -/ +lemma repGauge_generatorVal_mem (g : GaugeGroupI) (a : Generators) : + repGauge g (h.generatorVal a) ∈ h.massWeightSubmodule a.weight := by + cases a with + | H n l j => + simp only [generatorVal] + rw [h.repGauge_H g l _] + exact h.H_mem_massWeightSubmodule l _ + | barH n l j => + simp only [generatorVal] + rw [h.repGauge_barH g l _] + exact h.barH_mem_massWeightSubmodule l _ + | F n l μ ν j => + simp only [generatorVal] + rw [h.repGauge_F g l μ ν _] + exact h.F_mem_massWeightSubmodule l μ ν _ + | d i n l j => + simp only [generatorVal] + rw [h.repGauge_d g i l _] + exact h.d_mem_massWeightSubmodule i l _ + | bard i n l j => + simp only [generatorVal] + rw [h.repGauge_bard g i l _] + exact h.bard_mem_massWeightSubmodule i l _ + | u i n l j => + simp only [generatorVal] + rw [h.repGauge_u g i l _] + exact h.u_mem_massWeightSubmodule i l _ + | baru i n l j => + simp only [generatorVal] + rw [h.repGauge_baru g i l _] + exact h.baru_mem_massWeightSubmodule i l _ + | Q i n l j => + simp only [generatorVal] + rw [h.repGauge_Q g i l _] + exact h.Q_mem_massWeightSubmodule i l _ + | barQ i n l j => + simp only [generatorVal] + rw [h.repGauge_barQ g i l _] + exact h.barQ_mem_massWeightSubmodule i l _ + | L i n l j => + simp only [generatorVal] + rw [h.repGauge_L g i l _] + exact h.L_mem_massWeightSubmodule i l _ + | barL i n l j => + simp only [generatorVal] + rw [h.repGauge_barL g i l _] + exact h.barL_mem_massWeightSubmodule i l _ + | e i n l j => + simp only [generatorVal] + rw [h.repGauge_e g i l _] + exact h.e_mem_massWeightSubmodule i l _ + | bare i n l j => + simp only [generatorVal] + rw [h.repGauge_bare g i l _] + exact h.bare_mem_massWeightSubmodule i l _ + +/-- The Lorentz action carries a covariant generator into the mass-weight submodule + of its weight. -/ +lemma repLorentz_generatorVal_mem (Λ : SL(2,ℂ)) (a : Generators) : + repLorentz Λ (h.generatorVal a) ∈ h.massWeightSubmodule a.weight := by + cases a with + | H n l j => + simp only [generatorVal] + rw [h.repLorentz_H Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.H_mem_massWeightSubmodule p _) + | barH n l j => + simp only [generatorVal] + rw [h.repLorentz_barH Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.barH_mem_massWeightSubmodule p _) + | F n l μ ν j => + simp only [generatorVal] + rw [h.repLorentz_F Λ n l μ ν _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (Submodule.sum_mem _ fun a _ => Submodule.smul_mem _ _ + (Submodule.sum_mem _ fun b _ => Submodule.smul_mem _ _ + (h.F_mem_massWeightSubmodule p a b _))) + | d i n l j => + simp only [generatorVal] + rw [h.repLorentz_d i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.d_mem_massWeightSubmodule i p _) + | bard i n l j => + simp only [generatorVal] + rw [h.repLorentz_bard i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.bard_mem_massWeightSubmodule i p _) + | u i n l j => + simp only [generatorVal] + rw [h.repLorentz_u i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.u_mem_massWeightSubmodule i p _) + | baru i n l j => + simp only [generatorVal] + rw [h.repLorentz_baru i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.baru_mem_massWeightSubmodule i p _) + | Q i n l j => + simp only [generatorVal] + rw [h.repLorentz_Q i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.Q_mem_massWeightSubmodule i p _) + | barQ i n l j => + simp only [generatorVal] + rw [h.repLorentz_barQ i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.barQ_mem_massWeightSubmodule i p _) + | L i n l j => + simp only [generatorVal] + rw [h.repLorentz_L i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.L_mem_massWeightSubmodule i p _) + | barL i n l j => + simp only [generatorVal] + rw [h.repLorentz_barL i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.barL_mem_massWeightSubmodule i p _) + | e i n l j => + simp only [generatorVal] + rw [h.repLorentz_e i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.e_mem_massWeightSubmodule i p _) + | bare i n l j => + simp only [generatorVal] + rw [h.repLorentz_bare i Λ n l _] + exact Submodule.sum_mem _ fun p _ => Submodule.smul_mem _ _ + (h.bare_mem_massWeightSubmodule i p _) + +/-- The action `repGauge` preserves the mass-weight submodules. -/ +lemma repGauge_mem_massWeightSubmodule {w : ℕ} {x : B} (g : GaugeGroupI) + (hx : x ∈ h.massWeightSubmodule w) : repGauge g x ∈ h.massWeightSubmodule w := by + rw [h.massWeightSubmodule_eq_span] at hx + induction hx using Submodule.span_induction with + | mem y hyw => + obtain ⟨gl, hglw, rfl⟩ := hyw + subst hglw + induction gl with + | nil => + simp only [List.map_nil, List.prod_nil, List.sum_nil] + rw [h.repGauge_one g] + simpa using h.list_prod_mem_massWeightSubmodule (gl := ([] : List Generators)) rfl + | cons a t ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons] + rw [h.repGauge_mul g] + exact h.mul_mem_massWeightSubmodule (h.repGauge_generatorVal_mem g a) ih + | zero => rw [map_zero]; exact Submodule.zero_mem _ + | add a b ha hb iha ihb => rw [map_add]; exact Submodule.add_mem _ iha ihb + | smul c a ha iha => rw [map_smul]; exact Submodule.smul_mem _ _ iha + +/-- The action `repLorentz` preserves the mass-weight submodules. -/ +lemma repLorentz_mem_massWeightSubmodule {w : ℕ} {x : B} (Λ : SL(2,ℂ)) + (hx : x ∈ h.massWeightSubmodule w) : repLorentz Λ x ∈ h.massWeightSubmodule w := by + rw [h.massWeightSubmodule_eq_span] at hx + induction hx using Submodule.span_induction with + | mem y hyw => + obtain ⟨gl, hglw, rfl⟩ := hyw + subst hglw + induction gl with + | nil => + simp only [List.map_nil, List.prod_nil, List.sum_nil] + rw [h.repLorentz_one Λ] + simpa using h.list_prod_mem_massWeightSubmodule (gl := ([] : List Generators)) rfl + | cons a t ih => + simp only [List.map_cons, List.prod_cons, List.sum_cons] + rw [h.repLorentz_mul Λ] + exact h.mul_mem_massWeightSubmodule (h.repLorentz_generatorVal_mem Λ a) ih + | zero => rw [map_zero]; exact Submodule.zero_mem _ + | add a b ha hb iha ihb => rw [map_add]; exact Submodule.add_mem _ iha ihb + | smul c a ha iha => rw [map_smul]; exact Submodule.smul_mem _ _ iha + +/-- Components of pairwise distinct mass weights are independent: a vanishing sum + of weight-homogeneous elements has vanishing terms. -/ +lemma eq_zero_of_sum_massWeightSubmodule {n : ℕ} {w : Fin n → ℕ} + (hw : Function.Injective w) {f : Fin n → B} + (hf : ∀ i, f i ∈ h.massWeightSubmodule (w i)) (hsum : ∑ i, f i = 0) : + ∀ i, f i = 0 := by + intro i₀ + have hpoly := congrArg (fun z => Polynomial.coeff (massWeightPoly z) (w i₀)) hsum + simp only [map_sum, Polynomial.finsetSum_coeff, map_zero, Polynomial.coeff_zero] + at hpoly + rw [Finset.sum_congr rfl (fun i _ => by + rw [h.massWeightPoly_of_mem_massWeightSubmodule (hf i), + Polynomial.coeff_monomial]), + Finset.sum_eq_single i₀ + (fun i _ hne => if_neg fun hcontra => hne (hw hcontra)) + (by simp), if_pos rfl] at hpoly + exact hpoly + +/-- An invariant element decomposes into invariant weight components: if a gauge- + and Lorentz-invariant `x` is the sum of components of pairwise distinct mass + weights, every component is itself gauge and Lorentz invariant. -/ +lemma invariant_of_eq_sum_massWeightSubmodule {n : ℕ} {x : B} {w : Fin n → ℕ} + (hw : Function.Injective w) (f : Fin n → B) (hf : x = ∑ i, f i) + (hx : ∀ i, f i ∈ h.massWeightSubmodule (w i)) + (hgauge : ∀ g, repGauge g x = x) (hlorentz : ∀ Λ, repLorentz Λ x = x) : + ∀ i, (∀ g, repGauge g (f i) = f i) ∧ ∀ Λ, repLorentz Λ (f i) = f i := by + have key : ∀ T : B →ₗ[ℂ] B, T x = x → + (∀ i, T (f i) ∈ h.massWeightSubmodule (w i)) → ∀ i, T (f i) = f i := by + intro T hTx hTf i₀ + have hzero : ∑ i, (T (f i) - f i) = 0 := by + rw [Finset.sum_sub_distrib, ← map_sum, ← hf, hTx, sub_self] + have hcomp := h.eq_zero_of_sum_massWeightSubmodule hw + (f := fun i => T (f i) - f i) + (fun i => Submodule.sub_mem _ (hTf i) (hx i)) hzero i₀ + exact sub_eq_zero.mp hcomp + intro i + constructor + · intro g + exact key (repGauge g) (hgauge g) + (fun i => h.repGauge_mem_massWeightSubmodule g (hx i)) i + · intro Λ + exact key (repLorentz Λ) (hlorentz Λ) + (fun i => h.repLorentz_mem_massWeightSubmodule Λ (hx i)) i + +/-- The reduction of questions on invariants to invariants within + mass weight submodules. -/ +lemma invaraint_of_eq_sum_massWeightSubmodule {n : ℕ} {x : B} + (f : Fin n → B) (hf : x = ∑ i, f i) (hx : ∀ i, f i ∈ h.massWeightSubmodule i.val) + (hgauge : ∀ g, repGauge g x = x) (hlorentz : ∀ Λ, repLorentz Λ x = x) : + ∀ i, (∀ g, repGauge g (f i) = f i) ∧ ∀ Λ, repLorentz Λ (f i) = f i := + h.invariant_of_eq_sum_massWeightSubmodule Fin.val_injective f hf hx hgauge hlorentz + +end IsCovStandardModel + +end StandardModel diff --git a/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean b/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean new file mode 100644 index 000000000..a8cdb32d4 --- /dev/null +++ b/Physlib/Particles/StandardModel/IsStandardModel/Basic.lean @@ -0,0 +1,1687 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module +public import Physlib.Particles.StandardModel.Fermions.DownSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.LeptonSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.QuarkDoublet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.Fermions.UpSinglet.GaugeAlgebraAction +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Symmeterized +public import Physlib.Particles.StandardModel.HiggsBoson.GaugeAlgebraAction +/-! +# The algebra valued Standard model + +The basic idea here is to just reduce things +down to the covariant version. +In the covariant version we will do the work with +the invariants. + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups Lorentz + +structure IsStandardModel (B : Type) [Ring B] [Algebra ℂ B] + -- The representations + (repJet : Representation ℂ JetGaugeGroupI B) (repLorentz : Representation ℂ SL(2,ℂ) B) + -- The mass weights + (massWeightPoly : B →ₐ[ℂ] Polynomial B) + -- The Higgs fields + derivatives + (H : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B) + (barH : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B) + -- The gauge fields + derivatives + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + -- Three families of down-type quarks + derivatives + conjugates + (d : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B) + (bard : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B) + -- Three families of up-type quarks + derivatives + conjugates + (u : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B) + (baru : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B) + -- Three families of quark doublets + derivatives + conjugates + (Q : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B) + (barQ : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B) + -- Three families of lepton doublets + derivatives + conjugates + (L : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B) + (barL : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B) + -- Three families of lepton singlets + derivatives + conjugates + (e : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B) + (bare : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B) + : Prop where + -- *Gauge transformation* + -- The gauge field transforms as a gauge field: Lorentz covector symbols, the + -- all-orders adjoint Leibniz convolution with the Maurer–Cartan shift, and a + -- multiplicative gauge action + repJet_A : IsGaugeField repLorentz repJet A + -- The Higgs field and its conjugate transform in the Higgs representation + repJet_H : TransformsIn repJet HiggsVec.repJetGaugeGroupI H + repJet_barH : TransformsIn repJet (repConj HiggsVec.repJetGaugeGroupI) barH + -- The down-type quarks and their conjugates transform in the down-singlet + -- representation + repJet_d : ∀ i, TransformsIn repJet DownSinglet.repJetGaugeGroupI (d i) + repJet_bard : ∀ i, TransformsIn repJet (repConj DownSinglet.repJetGaugeGroupI) (bard i) + -- The up-type quarks and their conjugates transform in the up-singlet representation + repJet_u : ∀ i, TransformsIn repJet UpSinglet.repJetGaugeGroupI (u i) + repJet_baru : ∀ i, TransformsIn repJet (repConj UpSinglet.repJetGaugeGroupI) (baru i) + -- The quark doublets and their conjugates transform in the quark-doublet + -- representation + repJet_Q : ∀ i, TransformsIn repJet QuarkDoublet.repJetGaugeGroupI (Q i) + repJet_barQ : ∀ i, TransformsIn repJet (repConj QuarkDoublet.repJetGaugeGroupI) (barQ i) + -- The lepton doublets and their conjugates transform in the lepton-doublet + -- representation + repJet_L : ∀ i, TransformsIn repJet LeptonDoublet.repJetGaugeGroupI (L i) + repJet_barL : ∀ i, TransformsIn repJet (repConj LeptonDoublet.repJetGaugeGroupI) (barL i) + -- The lepton singlets and their conjugates transform in the lepton-singlet + -- representation + repJet_e : ∀ i, TransformsIn repJet LeptonSinglet.repJetGaugeGroupI (e i) + repJet_bare : ∀ i, TransformsIn repJet (repConj LeptonSinglet.repJetGaugeGroupI) (bare i) + -- *The Lorentz transformation* + -- The Lorentz transformations: the derivative slots of every field mix by per-slot + -- Lorentz matrices, the value index by the contragredient of the species' Lorentz + -- representation — the Higgs is a scalar, the fermions are Weyl spinors, and the + -- barred fields carry the conjugate representations + repLorentz_H : IsLorentzDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec) H + repLorentz_barH : IsLorentzDerivTransforms repLorentz + (Representation.trivial ℂ SL(2,ℂ) HiggsVec).conj barH + repLorentz_d : ∀ i, IsLorentzDerivTransforms repLorentz + DownSinglet.repLorentzGroup (d i) + repLorentz_bard : ∀ i, IsLorentzDerivTransforms repLorentz + DownSinglet.repLorentzGroup.conj (bard i) + repLorentz_u : ∀ i, IsLorentzDerivTransforms repLorentz + UpSinglet.repLorentzGroup (u i) + repLorentz_baru : ∀ i, IsLorentzDerivTransforms repLorentz + UpSinglet.repLorentzGroup.conj (baru i) + repLorentz_Q : ∀ i, IsLorentzDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup (Q i) + repLorentz_barQ : ∀ i, IsLorentzDerivTransforms repLorentz + QuarkDoublet.repLorentzGroup.conj (barQ i) + repLorentz_L : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup (L i) + repLorentz_barL : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonDoublet.repLorentzGroup.conj (barL i) + repLorentz_e : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup (e i) + repLorentz_bare : ∀ i, IsLorentzDerivTransforms repLorentz + LeptonSinglet.repLorentzGroup.conj (bare i) + -- **Mass weights (= 2 * mass dimension)** + -- Every derivative symbol is a `massWeightPoly`-eigenvector of pure monomial weight: + -- the bosons have mass dimension `1 + |s|` (weight `2 * (1 + |s|)`), the fermions + -- mass dimension `3/2 + |s|` (weight `3 + 2 * |s|`) + massWeight_H : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (H s φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (H s φ) + massWeight_barH : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (barH s φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (barH s φ) + massWeight_A : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) μ φ, + massWeightPoly (A s μ φ) = Polynomial.monomial (2 * (1 + Multiset.card s)) (A s μ φ) + massWeight_d : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (d i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (d i s φ) + massWeight_bard : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (bard i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (bard i s φ) + massWeight_u : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (u i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (u i s φ) + massWeight_baru : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (baru i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (baru i s φ) + massWeight_Q : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (Q i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (Q i s φ) + massWeight_barQ : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (barQ i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (barQ i s φ) + massWeight_L : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (L i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (L i s φ) + massWeight_barL : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (barL i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (barL i s φ) + massWeight_e : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (e i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (e i s φ) + massWeight_bare : ∀ i (s : Multiset (Fin 1 ⊕ Fin 3)) φ, + massWeightPoly (bare i s φ) = Polynomial.monomial (3 + 2 * Multiset.card s) (bare i s φ) + -- **Commutation**: the gauge field is bosonic — its derivative symbols commute with + -- each other and with every matter symbol (the matter symbols themselves are free to + -- anticommute among each other) + A_comm_A : ∀ (s s' : Multiset (Fin 1 ⊕ Fin 3)) (μ μ' : Fin 1 ⊕ Fin 3) + (ψ ψ' : Module.Dual ℝ GaugeAlgebra), Commute (A s μ ψ) (A s' μ' ψ') + A_comm_H : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ HiggsVec), + Commute (A s μ ψ) (H s' φ) + A_comm_barH : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + Commute (A s μ ψ) (barH s' φ) + A_comm_d : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ DownSinglet), + Commute (A s μ ψ) (d i s' φ) + A_comm_bard : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule DownSinglet)), + Commute (A s μ ψ) (bard i s' φ) + A_comm_u : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ UpSinglet), + Commute (A s μ ψ) (u i s' φ) + A_comm_baru : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule UpSinglet)), + Commute (A s μ ψ) (baru i s' φ) + A_comm_Q : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ QuarkDoublet), + Commute (A s μ ψ) (Q i s' φ) + A_comm_barQ : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + Commute (A s μ ψ) (barQ i s' φ) + A_comm_L : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ LeptonDoublet), + Commute (A s μ ψ) (L i s' φ) + A_comm_barL : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + Commute (A s μ ψ) (barL i s' φ) + A_comm_e : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ LeptonSinglet), + Commute (A s μ ψ) (e i s' φ) + A_comm_bare : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra) (i : Fin 3) (s' : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + Commute (A s μ ψ) (bare i s' φ) + +set_option linter.unusedVariables false +namespace IsStandardModel + +variable {B : Type} [Ring B] [Algebra ℂ B] + {repJet : Representation ℂ JetGaugeGroupI B} + {repLorentz : Representation ℂ SL(2,ℂ) B} + {massWeightPoly : B →ₐ[ℂ] Polynomial B} + {H : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ HiggsVec →ₗ[ℂ] B} + {barH : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B} + {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {d : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ DownSinglet →ₗ[ℂ] B} + {bard : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B} + {u : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ UpSinglet →ₗ[ℂ] B} + {baru : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B} + {Q : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B} + {barQ : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B} + {L : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B} + {barL : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B} + {e : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B} + {bare : Fin 3 → Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B} + (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) + + +/-! + +## A. The field algebra + +-/ + +/-- The algebra generated by all the fields of the Standard Model and their derivative + symbols: the gauge field, the Higgs and its conjugate, and the three families of each + fermion species with their conjugates. -/ +def fieldAlgebra (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare): Subalgebra ℂ B := + Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (s : Multiset (Fin 1 ⊕ Fin 3)), Set.range (H s) ∪ Set.range (barH s)) ∪ + (⋃ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)), + Set.range (d i s) ∪ Set.range (bard i s) ∪ + Set.range (u i s) ∪ Set.range (baru i s) ∪ + Set.range (Q i s) ∪ Set.range (barQ i s) ∪ + Set.range (L i s) ∪ Set.range (barL i s) ∪ + Set.range (e i s) ∪ Set.range (bare i s))) + +/-! + +## B. Covariant derivatives + +-/ + +include h in +noncomputable def covDerivD (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ DownSinglet →ₗ[ℂ] B := + IsGaugeField.covDerivIter A DownSinglet.gaugeAlgebraAction (d i) n l 0 + +noncomputable def covDerivBarD (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule DownSinglet) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) + (bard i) n l 0 + +/-- The iterated covariant derivative of the Higgs field. -/ +noncomputable def covDerivH (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ HiggsVec →ₗ[ℂ] B := + IsGaugeField.covDerivIter A HiggsVec.gaugeAlgebraAction H n l 0 + +/-- The iterated covariant derivative of the conjugate Higgs field. -/ +noncomputable def covDerivBarH (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule HiggsVec) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) + barH n l 0 + +/-- The iterated covariant derivative of the up-type quarks. -/ +noncomputable def covDerivU (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ UpSinglet →ₗ[ℂ] B := + IsGaugeField.covDerivIter A UpSinglet.gaugeAlgebraAction (u i) n l 0 + +/-- The iterated covariant derivative of the conjugate up-type quarks. -/ +noncomputable def covDerivBarU (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule UpSinglet) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) + (baru i) n l 0 + +/-- The iterated covariant derivative of the quark doublets. -/ +noncomputable def covDerivQ (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ QuarkDoublet →ₗ[ℂ] B := + IsGaugeField.covDerivIter A QuarkDoublet.gaugeAlgebraAction (Q i) n l 0 + +/-- The iterated covariant derivative of the conjugate quark doublets. -/ +noncomputable def covDerivBarQ (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule QuarkDoublet) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) + (barQ i) n l 0 + +/-- The iterated covariant derivative of the lepton doublets. -/ +noncomputable def covDerivL (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonDoublet →ₗ[ℂ] B := + IsGaugeField.covDerivIter A LeptonDoublet.gaugeAlgebraAction (L i) n l 0 + +/-- The iterated covariant derivative of the conjugate lepton doublets. -/ +noncomputable def covDerivBarL (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonDoublet) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) + (barL i) n l 0 + +/-- The iterated covariant derivative of the lepton singlets. -/ +noncomputable def covDerivE (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ LeptonSinglet →ₗ[ℂ] B := + IsGaugeField.covDerivIter A LeptonSinglet.gaugeAlgebraAction (e i) n l 0 + +/-- The iterated covariant derivative of the conjugate lepton singlets. -/ +noncomputable def covDerivBarE (h : IsStandardModel B repJet repLorentz massWeightPoly H barH A + d bard u baru Q barQ L barL e bare) (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ (ConjModule LeptonSinglet) →ₗ[ℂ] B := + IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) + (bare i) n l 0 + + +/-! + +## Gauge group actions on the covariant derivatives + +-/ + + +/-! + +## The algebra written in terms of covariant derivatives + + +-/ +/-- **The covariant field algebra**: replacing the plain derivative symbols of every + matter field — the Higgs, the fermions, and all their conjugates — by their covariant + derivative towers does not change the generated algebra; only the gauge-field symbols + remain plain. Each replacement is the span lemma + `IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter`, instantiated with the species' + infinitesimal action (`GaugeAlgebra.actionConj` of it for the conjugates). -/ +lemma fieldAlgebra_eq_covDeriv : + h.fieldAlgebra = Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + -- the span lemma, per field + have hATH : + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (HiggsVec)), + b = H s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (HiggsVec)), + b = IsGaugeField.covDerivIter A (HiggsVec.gaugeAlgebraAction) H n l 0 φ}) := + IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (HiggsVec.gaugeAlgebraAction) H + have hATbarH : + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + b = barH s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l 0 φ}) := + IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH + have hATd : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (DownSinglet)), + b = d i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (DownSinglet)), + b = IsGaugeField.covDerivIter A (DownSinglet.gaugeAlgebraAction) (d i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (DownSinglet.gaugeAlgebraAction) (d i) + have hATbard : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule DownSinglet)), + b = bard i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) + have hATu : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (UpSinglet)), + b = u i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (UpSinglet)), + b = IsGaugeField.covDerivIter A (UpSinglet.gaugeAlgebraAction) (u i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (UpSinglet.gaugeAlgebraAction) (u i) + have hATbaru : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule UpSinglet)), + b = baru i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) + have hATQ : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (QuarkDoublet)), + b = Q i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (QuarkDoublet)), + b = IsGaugeField.covDerivIter A (QuarkDoublet.gaugeAlgebraAction) (Q i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (QuarkDoublet.gaugeAlgebraAction) (Q i) + have hATbarQ : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + b = barQ i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) + have hATL : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (LeptonDoublet)), + b = L i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonDoublet)), + b = IsGaugeField.covDerivIter A (LeptonDoublet.gaugeAlgebraAction) (L i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (LeptonDoublet.gaugeAlgebraAction) (L i) + have hATbarL : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + b = barL i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) + have hATe : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (LeptonSinglet)), + b = e i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonSinglet)), + b = IsGaugeField.covDerivIter A (LeptonSinglet.gaugeAlgebraAction) (e i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (LeptonSinglet.gaugeAlgebraAction) (e i) + have hATbare : ∀ i : Fin 3, + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + b = bare i s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l 0 φ}) := + fun i => IsGaugeField.adjoin_symbols_eq_adjoin_covDerivIter (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) + -- every plain matter symbol lies in the covariant algebra + have hmem_H : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (HiggsVec)), + H s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro s φ + have h1 : H s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (HiggsVec)), + b = IsGaugeField.covDerivIter A (HiggsVec.gaugeAlgebraAction) H n l 0 φ}) := + hATH.le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, ?_⟩⟩)) + have hmem : IsGaugeField.covDerivIter A (HiggsVec.gaugeAlgebraAction) H n l 0 φ' + ∈ Set.range (h.covDerivH l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_barH : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule HiggsVec)), + barH s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro s φ + have h1 : barH s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l 0 φ}) := + hATbarH.le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨n, Set.mem_iUnion.mpr ⟨l, ?_⟩⟩)) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l 0 φ' + ∈ Set.range (h.covDerivBarH l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_d : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (DownSinglet)), + d i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : d i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (DownSinglet)), + b = IsGaugeField.covDerivIter A (DownSinglet.gaugeAlgebraAction) (d i) n l 0 φ}) := + (hATd i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (DownSinglet.gaugeAlgebraAction) (d i) n l 0 φ' + ∈ Set.range (h.covDerivD i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_bard : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), + bard i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : bard i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l 0 φ}) := + (hATbard i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l 0 φ' + ∈ Set.range (h.covDerivBarD i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_u : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (UpSinglet)), + u i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : u i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (UpSinglet)), + b = IsGaugeField.covDerivIter A (UpSinglet.gaugeAlgebraAction) (u i) n l 0 φ}) := + (hATu i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (UpSinglet.gaugeAlgebraAction) (u i) n l 0 φ' + ∈ Set.range (h.covDerivU i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_baru : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), + baru i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : baru i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l 0 φ}) := + (hATbaru i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l 0 φ' + ∈ Set.range (h.covDerivBarU i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_Q : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (QuarkDoublet)), + Q i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : Q i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (QuarkDoublet)), + b = IsGaugeField.covDerivIter A (QuarkDoublet.gaugeAlgebraAction) (Q i) n l 0 φ}) := + (hATQ i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (QuarkDoublet.gaugeAlgebraAction) (Q i) n l 0 φ' + ∈ Set.range (h.covDerivQ i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_barQ : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + barQ i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : barQ i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l 0 φ}) := + (hATbarQ i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l 0 φ' + ∈ Set.range (h.covDerivBarQ i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_L : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonDoublet)), + L i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : L i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonDoublet)), + b = IsGaugeField.covDerivIter A (LeptonDoublet.gaugeAlgebraAction) (L i) n l 0 φ}) := + (hATL i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (LeptonDoublet.gaugeAlgebraAction) (L i) n l 0 φ' + ∈ Set.range (h.covDerivL i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_barL : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + barL i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : barL i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l 0 φ}) := + (hATbarL i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l 0 φ' + ∈ Set.range (h.covDerivBarL i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_e : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonSinglet)), + e i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : e i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonSinglet)), + b = IsGaugeField.covDerivIter A (LeptonSinglet.gaugeAlgebraAction) (e i) n l 0 φ}) := + (hATe i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (LeptonSinglet.gaugeAlgebraAction) (e i) n l 0 φ' + ∈ Set.range (h.covDerivE i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + have hmem_bare : ∀ (i : Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + bare i s φ ∈ Algebra.adjoin ℂ + ((⋃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3), Set.range (A s μ)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + intro i s φ + have h1 : bare i s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), + b = IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l 0 φ}) := + (hATbare i).le (Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨n, l, φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨n, + Set.mem_iUnion.mpr ⟨l, ?_⟩⟩⟩) + have hmem : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l 0 φ' + ∈ Set.range (h.covDerivBarE i l) := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + refine le_antisymm (Algebra.adjoin_le ?_) (Algebra.adjoin_le ?_) + · rintro b (hAH | hbF) + · rcases hAH with hA | hH + · exact Algebra.subset_adjoin (Or.inl (Or.inl hA)) + · simp only [Set.mem_iUnion] at hH + obtain ⟨s, hH⟩ := hH + rcases hH with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · exact hmem_H s φ + · exact hmem_barH s φ + · simp only [Set.mem_iUnion] at hbF + obtain ⟨i, s, hbF⟩ := hbF + rcases hbF with (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) + · exact hmem_d i s φ + · exact hmem_bard i s φ + · exact hmem_u i s φ + · exact hmem_baru i s φ + · exact hmem_Q i s φ + · exact hmem_barQ i s φ + · exact hmem_L i s φ + · exact hmem_barL i s φ + · exact hmem_e i s φ + · exact hmem_bare i s φ + · rintro b ((hA | hHT) | hFT) + · exact Algebra.subset_adjoin (Or.inl (Or.inl hA)) + · simp only [Set.mem_iUnion] at hHT + obtain ⟨n, l, hHT⟩ := hHT + rcases hHT with ⟨φ, rfl⟩ | ⟨φ, rfl⟩ + · have h1 : IsGaugeField.covDerivIter A (HiggsVec.gaugeAlgebraAction) H n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (HiggsVec)), b = H s φ}) := + hATH.ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨s', ?_⟩)) + exact Or.inl ⟨φ', rfl⟩ + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule HiggsVec)), b = barH s φ}) := + hATbarH.ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inl (Or.inr (Set.mem_iUnion.mpr ⟨s', ?_⟩)) + exact Or.inr ⟨φ', rfl⟩ + · simp only [Set.mem_iUnion] at hFT + obtain ⟨i, n, l, hFT⟩ := hFT + rcases hFT with (((((((((⟨φ, rfl⟩ | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | + ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) | ⟨φ, rfl⟩) + · have h1 : IsGaugeField.covDerivIter A (DownSinglet.gaugeAlgebraAction) (d i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (DownSinglet)), b = d i s φ}) := + (hATd i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : d i s' φ' ∈ Set.range (d i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule DownSinglet)), b = bard i s φ}) := + (hATbard i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : bard i s' φ' ∈ Set.range (bard i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (UpSinglet.gaugeAlgebraAction) (u i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (UpSinglet)), b = u i s φ}) := + (hATu i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : u i s' φ' ∈ Set.range (u i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule UpSinglet)), b = baru i s φ}) := + (hATbaru i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : baru i s' φ' ∈ Set.range (baru i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (QuarkDoublet.gaugeAlgebraAction) (Q i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (QuarkDoublet)), b = Q i s φ}) := + (hATQ i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : Q i s' φ' ∈ Set.range (Q i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule QuarkDoublet)), b = barQ i s φ}) := + (hATbarQ i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : barQ i s' φ' ∈ Set.range (barQ i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (LeptonDoublet.gaugeAlgebraAction) (L i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonDoublet)), b = L i s φ}) := + (hATL i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : L i s' φ' ∈ Set.range (L i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonDoublet)), b = barL i s φ}) := + (hATbarL i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : barL i s' φ' ∈ Set.range (barL i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (LeptonSinglet.gaugeAlgebraAction) (e i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (LeptonSinglet)), b = e i s φ}) := + (hATe i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : e i s' φ' ∈ Set.range (e i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + · have h1 : IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l 0 φ + ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule LeptonSinglet)), b = bare i s φ}) := + (hATbare i).ge (Algebra.subset_adjoin (Or.inr ⟨n, l, φ, rfl⟩)) + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) h1 + rintro b (⟨u', μ, ψ, rfl⟩ | ⟨s', φ', rfl⟩) + · exact Or.inl (Or.inl + (Set.mem_iUnion.mpr ⟨u', Set.mem_iUnion.mpr ⟨μ, ⟨ψ, rfl⟩⟩⟩)) + · refine Or.inr (Set.mem_iUnion.mpr ⟨i, Set.mem_iUnion.mpr ⟨s', ?_⟩⟩) + have hmem : bare i s' φ' ∈ Set.range (bare i s') := ⟨φ', rfl⟩ + simp only [Set.mem_union] + tauto + +/-! + +## C. Gauge covariance of the covariant derivatives + +-/ + +include h in +/-- **Gauge covariance of the covariant derivatives of the Higgs field**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (HiggsVec.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (HiggsVec.gaugeAlgebraAction) H n l) := + TransformsIn.covDerivIter h.repJet_A h.repJet_H (HiggsVec.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate Higgs field**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarH (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj HiggsVec.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l) := + TransformsIn.covDerivIter h.repJet_A h.repJet_barH (HiggsVec.isInfinitesimalActionOf.conj) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the down-type quarks**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivD (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (DownSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (DownSinglet.gaugeAlgebraAction) (d i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_d i) (DownSinglet.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate down-type quarks**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarD (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj DownSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_bard i) (DownSinglet.isInfinitesimalActionOf.conj) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the up-type quarks**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivU (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (UpSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (UpSinglet.gaugeAlgebraAction) (u i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_u i) (UpSinglet.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate up-type quarks**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarU (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj UpSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_baru i) (UpSinglet.isInfinitesimalActionOf.conj) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the quark doublets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivQ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (QuarkDoublet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (QuarkDoublet.gaugeAlgebraAction) (Q i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_Q i) (QuarkDoublet.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate quark doublets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarQ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj QuarkDoublet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_barQ i) (QuarkDoublet.isInfinitesimalActionOf.conj) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the lepton doublets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivL (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (LeptonDoublet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (LeptonDoublet.gaugeAlgebraAction) (L i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_L i) (LeptonDoublet.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate lepton doublets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarL (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj LeptonDoublet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_barL i) (LeptonDoublet.isInfinitesimalActionOf.conj) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the lepton singlets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivE (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (LeptonSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (LeptonSinglet.gaugeAlgebraAction) (e i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_e i) (LeptonSinglet.isInfinitesimalActionOf) n l + +include h in +/-- **Gauge covariance of the covariant derivatives of the conjugate lepton singlets**: every derivative + symbol of the tower transforms by the pure Leibniz convolution of the dual + representation coefficients, with no inhomogeneous term. -/ +lemma transformsIn_covDerivBarE (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) : + TransformsIn repJet (repConj LeptonSinglet.repJetGaugeGroupI) + (IsGaugeField.covDerivIter A (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l) := + TransformsIn.covDerivIter h.repJet_A (h.repJet_bare i) (LeptonSinglet.isInfinitesimalActionOf.conj) n l + +/-! + +## D. The field strength and its covariant derivatives + +-/ + +/-- The iterated covariant derivative `∇_{l₁} ⋯ ∇_{lₙ} F_{μν}` of the field strength + of the gauge field, along an ordered list of directions. -/ +noncomputable def covDerivFieldStrength (h : IsStandardModel B repJet repLorentz + massWeightPoly H barH A d bard u baru Q barQ L barL e bare) + (l : List (Fin 1 ⊕ Fin 3)) (μ ν : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B := + IsGaugeField.iteratedCovDerivAdjoint A l (IsGaugeField.fieldStrength A μ ν) 0 + +include h in +/-- **Gauge covariance of the covariant derivatives of the field strength**: every + derivative symbol of the tower transforms in the adjoint, with no inhomogeneous + term. -/ +lemma transformsInAdjoint_covDerivFieldStrength (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) : + IsGaugeField.TransformsInAdjoint repJet + (IsGaugeField.iteratedCovDerivAdjoint A l (IsGaugeField.fieldStrength A μ ν)) := + IsGaugeField.transformsInAdjoint_iteratedCovDerivAdjoint h.repJet_A l μ ν + +include h in +/-- **The covariant derivatives of the field strength transform under just the global + gauge group**: the whole gauge jet acts through the base-point adjoint coefficient + of its value alone — no derivative of the gauge transformation enters. -/ +lemma repJet_covDerivFieldStrength (U : JetGaugeGroupI) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repJet U (h.covDerivFieldStrength l μ ν φ) = + h.covDerivFieldStrength l μ ν (adjointDualCoeff U⁻¹ 0 φ) := by + have h1 := h.transformsInAdjoint_covDerivFieldStrength l μ ν U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **Pure gauge jets act trivially on the covariant derivatives of the field + strength**: gauge jets with trivial base-point value fix the whole covariant + tower. -/ +lemma repJet_covDerivFieldStrength_of_mem_truncationKer_zero + (U : JetGaugeGroupI.truncationKer 0) (l : List (Fin 1 ⊕ Fin 3)) + (μ ν : Fin 1 ⊕ Fin 3) (φ : Module.Dual ℝ GaugeAlgebra) : + repJet U.1 (h.covDerivFieldStrength l μ ν φ) = h.covDerivFieldStrength l μ ν φ := + IsGaugeField.repGauge_iteratedCovDerivAdjoint_fieldStrength_of_mem_truncationKer_zero + h.repJet_A U l μ ν φ + +/-! + +## E. The matter covariant derivatives transform through the base point + +-/ + +include h in +/-- **The covariant derivatives of the Higgs field transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivH l φ) = + h.covDerivH l (IsGaugeField.repDualCoeff (HiggsVec.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivH n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate Higgs field transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarH {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarH l φ) = + h.covDerivBarH l (IsGaugeField.repDualCoeff (repConj HiggsVec.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarH n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the down-type quarks transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivD i l φ) = + h.covDerivD i l (IsGaugeField.repDualCoeff (DownSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivD i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate down-type quarks transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarD (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarD i l φ) = + h.covDerivBarD i l (IsGaugeField.repDualCoeff (repConj DownSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarD i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the up-type quarks transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivU i l φ) = + h.covDerivU i l (IsGaugeField.repDualCoeff (UpSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivU i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate up-type quarks transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarU (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarU i l φ) = + h.covDerivBarU i l (IsGaugeField.repDualCoeff (repConj UpSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarU i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the quark doublets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivQ i l φ) = + h.covDerivQ i l (IsGaugeField.repDualCoeff (QuarkDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivQ i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate quark doublets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarQ (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarQ i l φ) = + h.covDerivBarQ i l (IsGaugeField.repDualCoeff (repConj QuarkDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarQ i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the lepton doublets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivL i l φ) = + h.covDerivL i l (IsGaugeField.repDualCoeff (LeptonDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivL i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate lepton doublets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarL (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarL i l φ) = + h.covDerivBarL i l (IsGaugeField.repDualCoeff (repConj LeptonDoublet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarL i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the lepton singlets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivE i l φ) = + h.covDerivE i l (IsGaugeField.repDualCoeff (LeptonSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivE i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +include h in +/-- **The covariant derivatives of the conjugate lepton singlets transform under just the global + gauge group**: the whole gauge jet acts through the base-point dual representation + coefficient of its value alone. -/ +lemma repJet_covDerivBarE (i : Fin 3) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) + (U : JetGaugeGroupI) (φ) : + repJet U (h.covDerivBarE i l φ) = + h.covDerivBarE i l (IsGaugeField.repDualCoeff (repConj LeptonSinglet.repJetGaugeGroupI) U⁻¹ 0 φ) := by + have h1 := h.transformsIn_covDerivBarE i n l U φ 0 + simp only [Multiset.antidiagonal_zero, Multiset.map_singleton, + Multiset.sum_singleton] at h1 + exact h1 + +/-! + +## F. Pure gauge jets fix the matter covariant derivatives + +-/ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + Higgs field: together with `repJet_covDerivH`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivH_of_mem_truncationKer_zero {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivH l φ) = h.covDerivH l φ := + (h.transformsIn_covDerivH n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => HiggsVec.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate Higgs field: together with `repJet_covDerivBarH`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarH_of_mem_truncationKer_zero {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarH l φ) = h.covDerivBarH l φ := + (h.transformsIn_covDerivBarH n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (HiggsVec.repCoeff_zero_of_eval_eq_one hW)) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + DownSinglet fields: together with `repJet_covDerivD`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivD_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivD i l φ) = h.covDerivD i l φ := + (h.transformsIn_covDerivD i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => DownSinglet.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate DownSinglet fields: together with `repJet_covDerivBarD`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarD_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarD i l φ) = h.covDerivBarD i l φ := + (h.transformsIn_covDerivBarD i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (DownSinglet.repCoeff_zero_of_eval_eq_one hW)) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + UpSinglet fields: together with `repJet_covDerivU`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivU_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivU i l φ) = h.covDerivU i l φ := + (h.transformsIn_covDerivU i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => UpSinglet.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate UpSinglet fields: together with `repJet_covDerivBarU`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarU_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarU i l φ) = h.covDerivBarU i l φ := + (h.transformsIn_covDerivBarU i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (UpSinglet.repCoeff_zero_of_eval_eq_one hW)) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + QuarkDoublet fields: together with `repJet_covDerivQ`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivQ_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivQ i l φ) = h.covDerivQ i l φ := + (h.transformsIn_covDerivQ i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => QuarkDoublet.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate QuarkDoublet fields: together with `repJet_covDerivBarQ`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarQ_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarQ i l φ) = h.covDerivBarQ i l φ := + (h.transformsIn_covDerivBarQ i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (QuarkDoublet.repCoeff_zero_of_eval_eq_one hW)) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + LeptonDoublet fields: together with `repJet_covDerivL`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivL_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivL i l φ) = h.covDerivL i l φ := + (h.transformsIn_covDerivL i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => LeptonDoublet.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate LeptonDoublet fields: together with `repJet_covDerivBarL`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarL_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarL i l φ) = h.covDerivBarL i l φ := + (h.transformsIn_covDerivBarL i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (LeptonDoublet.repCoeff_zero_of_eval_eq_one hW)) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + LeptonSinglet fields: together with `repJet_covDerivE`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivE_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivE i l φ) = h.covDerivE i l φ := + (h.transformsIn_covDerivE i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => LeptonSinglet.repCoeff_zero_of_eval_eq_one hW) U φ + +include h in +/-- Pure gauge jets act trivially on the covariant derivatives of the + conjugate LeptonSinglet fields: together with `repJet_covDerivBarE`, the + tower transforms under just the global gauge group. -/ +lemma repJet_covDerivBarE_of_mem_truncationKer_zero (i : Fin 3) {n : ℕ} + (l : Fin n → (Fin 1 ⊕ Fin 3)) (U : JetGaugeGroupI.truncationKer 0) (φ) : + repJet U.1 (h.covDerivBarE i l φ) = h.covDerivBarE i l φ := + (h.transformsIn_covDerivBarE i n l).repGauge_eq_of_mem_truncationKer_zero + (fun hW => GaugeAlgebra.repCoeff_repConj_zero_eq_id (LeptonSinglet.repCoeff_zero_of_eval_eq_one hW)) U φ + +/-! + +## G. The classification of gauge invariants + +-/ + +include h in +set_option maxHeartbeats 1000000 in +/-- **The classification of gauge invariants of the Standard Model field algebra**: + a `repJet`-invariant element of the field algebra is a polynomial in the covariant + derivatives of the field strength and the covariant derivatives of the matter + fields. Gauge invariance eliminates the bare gauge-field symbols; only the covariant + objects — all of which transform under just the global gauge group — remain. -/ +theorem invariant_mem_adjoin_covDeriv {x : B} + (hx : x ∈ h.fieldAlgebra) + (hinv : ∀ U : JetGaugeGroupI, repJet U x = x) : + x ∈ Algebra.adjoin ℂ + ((⋃ (l : List (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (ν : Fin 1 ⊕ Fin 3), + Set.range (h.covDerivFieldStrength l μ ν)) ∪ + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l))) := by + set S : Set B := + (⋃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivH l) ∪ Set.range (h.covDerivBarH l)) ∪ + (⋃ (i : Fin 3) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)), + Set.range (h.covDerivD i l) ∪ Set.range (h.covDerivBarD i l) ∪ + Set.range (h.covDerivU i l) ∪ Set.range (h.covDerivBarU i l) ∪ + Set.range (h.covDerivQ i l) ∪ Set.range (h.covDerivBarQ i l) ∪ + Set.range (h.covDerivL i l) ∪ Set.range (h.covDerivBarL i l) ∪ + Set.range (h.covDerivE i l) ∪ Set.range (h.covDerivBarE i l)) with hSdef + -- the matter covariant towers commute with the gauge-field symbols + have hcS : ∀ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), ∀ y ∈ S, Commute y (A p μ ψ) := by + intro p μ ψ y hy + rw [hSdef] at hy + rcases hy with hy | hy + · simp only [Set.mem_iUnion] at hy + obtain ⟨n, l, hy⟩ := hy + rcases hy with ⟨φ', rfl⟩ | ⟨φ', rfl⟩ + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (HiggsVec.gaugeAlgebraAction) H n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_H p μ ψ s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj HiggsVec.gaugeAlgebraAction) barH n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_barH p μ ψ s' φ'').symm + · simp only [Set.mem_iUnion] at hy + obtain ⟨i, n, l, hy⟩ := hy + rcases hy with (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (DownSinglet.gaugeAlgebraAction) (d i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_d p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj DownSinglet.gaugeAlgebraAction) (bard i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_bard p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (UpSinglet.gaugeAlgebraAction) (u i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_u p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj UpSinglet.gaugeAlgebraAction) (baru i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_baru p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (QuarkDoublet.gaugeAlgebraAction) (Q i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_Q p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj QuarkDoublet.gaugeAlgebraAction) (barQ i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_barQ p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (LeptonDoublet.gaugeAlgebraAction) (L i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_L p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj LeptonDoublet.gaugeAlgebraAction) (barL i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_barL p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (LeptonSinglet.gaugeAlgebraAction) (e i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_e p μ ψ i s' φ'').symm + · refine IsGaugeField.commute_of_mem_adjoin ?_ + (IsGaugeField.covDerivIter_mem_adjoin_symbols + (GaugeAlgebra.actionConj LeptonSinglet.gaugeAlgebraAction) (bare i) n l 0 φ') + rintro x' (⟨s', μ', ψ', rfl⟩ | ⟨s', φ'', rfl⟩) + · exact h.A_comm_A s' p μ' μ ψ' ψ + · exact (h.A_comm_bare p μ ψ i s' φ'').symm + -- the matter covariant towers are fixed by pure gauge jets + have hS : ∀ y ∈ S, ∀ U : JetGaugeGroupI.truncationKer 0, repJet U.1 y = y := by + intro y hy U + rw [hSdef] at hy + rcases hy with hy | hy + · simp only [Set.mem_iUnion] at hy + obtain ⟨n, l, hy⟩ := hy + rcases hy with ⟨φ', rfl⟩ | ⟨φ', rfl⟩ + · exact h.repJet_covDerivH_of_mem_truncationKer_zero l U φ' + · exact h.repJet_covDerivBarH_of_mem_truncationKer_zero l U φ' + · simp only [Set.mem_iUnion] at hy + obtain ⟨i, n, l, hy⟩ := hy + rcases hy with (((((((((⟨φ', rfl⟩ | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | + ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) | ⟨φ', rfl⟩) + · exact h.repJet_covDerivD_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivBarD_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivU_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivBarU_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivQ_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivBarQ_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivL_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivBarL_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivE_of_mem_truncationKer_zero i l U φ' + · exact h.repJet_covDerivBarE_of_mem_truncationKer_zero i l U φ' + -- the invariant lies in the algebra of gauge symbols over the matter towers + have hx' : x ∈ Algebra.adjoin ℂ + ({b : B | ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A p μ ψ} ∪ S) := by + rw [h.fieldAlgebra_eq_covDeriv] at hx + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) hx + rintro b ((hA | hHT) | hFT) + · simp only [Set.mem_iUnion, Set.mem_range] at hA + obtain ⟨s, μ, ψ, hψ⟩ := hA + exact Or.inl ⟨s, μ, ψ, hψ.symm⟩ + · exact Or.inr (Or.inl hHT) + · exact Or.inr (Or.inr hFT) + -- the abstract classification + have hres := IsGaugeField.invariant_mem_adjoin_fieldStrength h.repJet_A + (fun p q μ ν φ ψ => h.A_comm_A p q μ ν φ ψ) S hcS hS hx' hinv + refine SetLike.le_def.mp (Algebra.adjoin_mono ?_) hres + rintro b (⟨l, ν, lam, φ', rfl⟩ | hbS) + · exact Or.inl (Or.inl (Set.mem_iUnion.mpr ⟨l, Set.mem_iUnion.mpr ⟨ν, + Set.mem_iUnion.mpr ⟨lam, ⟨φ', rfl⟩⟩⟩⟩)) + · rw [hSdef] at hbS + rcases hbS with h1 | h2 + · exact Or.inl (Or.inr h1) + · exact Or.inr h2 + +end IsStandardModel + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean b/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean new file mode 100644 index 000000000..573caf344 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Basic.lean @@ -0,0 +1,155 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Fermions.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.HiggsBoson.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Basic +/-! +# The jet algebra of the Standard Model + +## i. Overview + +The full jet algebra of the Standard Model — the algebra in which a Standard Model +Lagrangian lives — is the tensor product of its three sector algebras: the fermionic jet +algebra `FermionJetAlgebra`, the Higgs jet algebra `HiggsJetAlgebra`, and the +(complexified) gauge-boson jet algebra `GaugeJetAlgebra`. The bosonic factors commute with +everything, so the ordinary tensor product is correct; the anticommutativity of the +fermions lives entirely inside the fermionic factor. + +This file defines the algebra and its three sector inclusions, and proves that the gauge +sector is central. The Lorentz action, the jet gauge action, the formal total derivative +and the mass-dimension scaling are assembled factorwise in the sibling files. + +## ii. Key results + +- `JetAlgebra` : the jet algebra of the Standard Model. +- `JetAlgebra.includeFermion`, `includeHiggs`, `includeGauge` : the sector inclusions. +- `JetAlgebra.includeGauge_commute` : the gauge sector is central. +- `Representation.tprod_apply_mul` : multiplicativity of tensor-product representations, + the generic assembly used by the action files. + +## iii. Table of contents + +- A. The jet algebra of the Standard Model + - A.1. The sector inclusions + - A.2. Centrality of the gauge sector +- B. Tensor products of multiplicative representations + +-/ + +@[expose] public section + +set_option maxHeartbeats 8000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +/-! + +## A. The jet algebra of the Standard Model + +-/ + +/-- **The jet algebra of the Standard Model**: the tensor product of the fermionic, Higgs + and gauge-boson jet algebras. A Standard Model Lagrangian is an element of this + algebra. -/ +abbrev JetAlgebra : Type := + (FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) ⊗[ℂ] (ℂ ⊗[ℝ] GaugeJetAlgebra) + +namespace JetAlgebra + +/-! + +### A.1. The sector inclusions + +-/ + +/-- The inclusion of the fermionic sector. -/ +noncomputable def includeFermion : FermionJetAlgebra →ₐ[ℂ] JetAlgebra := + (Algebra.TensorProduct.includeLeft + (R := ℂ) (S := ℂ) (B := ℂ ⊗[ℝ] GaugeJetAlgebra)).comp + Algebra.TensorProduct.includeLeft + +/-- The inclusion of the Higgs sector. -/ +noncomputable def includeHiggs : HiggsJetAlgebra →ₐ[ℂ] JetAlgebra := + (Algebra.TensorProduct.includeLeft + (R := ℂ) (S := ℂ) (B := ℂ ⊗[ℝ] GaugeJetAlgebra)).comp + Algebra.TensorProduct.includeRight + +/-- The inclusion of the gauge sector. -/ +noncomputable def includeGauge : (ℂ ⊗[ℝ] GaugeJetAlgebra) →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.includeRight + +lemma includeGauge_apply (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + includeGauge y + = ((1 : FermionJetAlgebra) ⊗ₜ[ℂ] (1 : HiggsJetAlgebra)) ⊗ₜ[ℂ] y := rfl + +/-! + +### A.2. Centrality of the gauge sector + +-/ + +/-- The right factor of a tensor product with a commutative right factor is central: + the abstract statement, proved by tensor induction at abstract types so that it can be + instantiated on the jet algebra without rewriting inside it. -/ +private lemma tensor_includeRight_comm {A B : Type*} [Ring A] [Algebra ℂ A] + [CommRing B] [Algebra ℂ B] (y : B) (x : A ⊗[ℂ] B) : + x * Algebra.TensorProduct.includeRight (R := ℂ) (A := A) y + = Algebra.TensorProduct.includeRight (R := ℂ) (A := A) y * x := by + induction x using TensorProduct.induction_on with + | zero => rw [zero_mul, mul_zero] + | add a b ha hb => rw [add_mul, mul_add, ha, hb] + | tmul w g => + rw [show (Algebra.TensorProduct.includeRight (R := ℂ) (A := A) y : A ⊗[ℂ] B) + = (1 : A) ⊗ₜ[ℂ] y from rfl, + Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul, + mul_one, one_mul, mul_comm g y] + +/-- The image of the gauge sector is central: gauge-boson symbols commute with + everything, as bosons must. -/ +lemma includeGauge_commute (y : ℂ ⊗[ℝ] GaugeJetAlgebra) (x : JetAlgebra) : + x * includeGauge y = includeGauge y * x := + tensor_includeRight_comm y x + +/-! + +## B. Tensor products of multiplicative representations + +-/ + +/-- The tensor product of two multiplicative representations on algebras is + multiplicative. -/ +lemma _root_.Representation.tprod_apply_mul {k G A B : Type*} [CommSemiring k] [Monoid G] + [Ring A] [Algebra k A] [Ring B] [Algebra k B] + (ρ : Representation k G A) (σ : Representation k G B) + (hρ : ∀ (g : G) (x y : A), ρ g (x * y) = ρ g x * ρ g y) + (hσ : ∀ (g : G) (x y : B), σ g (x * y) = σ g x * σ g y) + (g : G) (x y : A ⊗[k] B) : + (ρ.tprod σ) g (x * y) = (ρ.tprod σ) g x * (ρ.tprod σ) g y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => rw [add_mul, map_add, map_add, h₁, h₂, add_mul] + | tmul a₁ b₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => rw [mul_add, map_add, map_add, h₁, h₂, mul_add] + | tmul a₂ b₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, + show (ρ.tprod σ) g (a₁ ⊗ₜ[k] b₁) = ρ g a₁ ⊗ₜ[k] σ g b₁ from rfl, + show (ρ.tprod σ) g (a₂ ⊗ₜ[k] b₂) = ρ g a₂ ⊗ₜ[k] σ g b₂ from rfl, + show (ρ.tprod σ) g ((a₁ * a₂) ⊗ₜ[k] (b₁ * b₂)) + = ρ g (a₁ * a₂) ⊗ₜ[k] σ g (b₁ * b₂) from rfl, + hρ, hσ, Algebra.TensorProduct.tmul_mul_tmul] + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/GaugeAction.lean b/Physlib/Particles/StandardModel/JetAlgebra/GaugeAction.lean new file mode 100644 index 000000000..88a25dd59 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/GaugeAction.lean @@ -0,0 +1,111 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.GaugeAction +/-! +# The jet gauge action on the jet algebra of the Standard Model + +## i. Overview + +The jet gauge group acts on the jet algebra of the Standard Model sector by sector: the +tensor product of the fermionic, Higgs and complexified gauge-boson actions. The action is +multiplicative — a jet of gauge transformations acts on a Lagrangian term factor by +factor — and restricts to the gauge sector's own substitution action through the sector +inclusion. + +## ii. Key results + +- `JetAlgebra.repJetGaugeGroupI` : the jet gauge action. +- `JetAlgebra.repJetGaugeGroupI_apply_mul` : the action is multiplicative. +- `JetAlgebra.repJetGaugeGroupI_includeGauge` : the restriction to the gauge sector. + +## iii. Table of contents + +- A. The action of the jet gauge group + - A.1. Multiplicativity + - A.2. The action on the gauge sector + +-/ + +@[expose] public section + +set_option maxHeartbeats 8000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +namespace JetAlgebra + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- The jet gauge action on the jet algebra of the Standard Model: the three sectors + transform independently. -/ +noncomputable def repJetGaugeGroupI : Representation ℂ JetGaugeGroupI JetAlgebra := + (FermionJetAlgebra.repJetGaugeGroupI.tprod HiggsJetAlgebra.repJetGaugeGroupI).tprod + GaugeJetAlgebra.complexRepJetGaugeGroupI + +@[simp] +lemma repJetGaugeGroupI_tmul (U : JetGaugeGroupI) + (w : FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) (g : ℂ ⊗[ℝ] GaugeJetAlgebra) : + repJetGaugeGroupI U (w ⊗ₜ[ℂ] g) + = ((FermionJetAlgebra.repJetGaugeGroupI.tprod + HiggsJetAlgebra.repJetGaugeGroupI) U w) + ⊗ₜ[ℂ] (GaugeJetAlgebra.complexRepJetGaugeGroupI U g) := rfl + +/-! + +### A.1. Multiplicativity + +-/ + +/-- The jet gauge action on the jet algebra is multiplicative: a jet of gauge + transformations acts on a Lagrangian term factor by factor. -/ +lemma repJetGaugeGroupI_apply_mul (U : JetGaugeGroupI) (x y : JetAlgebra) : + repJetGaugeGroupI U (x * y) = repJetGaugeGroupI U x * repJetGaugeGroupI U y := + Representation.tprod_apply_mul _ _ + (Representation.tprod_apply_mul _ _ + (FermionicAlgebra.repJetGaugeGroupI_apply_mul _ _) + (BosonicAlgebra.repJetGaugeGroupI_apply_mul _ _)) + GaugeJetAlgebra.complexRepJetGaugeGroupI_apply_mul U x y + +/-! + +### A.2. The action on the gauge sector + +-/ + +/-- The jet gauge action restricts to the gauge sector's own action. -/ +lemma repJetGaugeGroupI_includeGauge (U : JetGaugeGroupI) + (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + repJetGaugeGroupI U (includeGauge y) + = includeGauge (GaugeJetAlgebra.complexRepJetGaugeGroupI U y) := by + rw [includeGauge_apply, repJetGaugeGroupI_tmul, + show (FermionJetAlgebra.repJetGaugeGroupI.tprod + HiggsJetAlgebra.repJetGaugeGroupI) U + ((1 : FermionJetAlgebra) ⊗ₜ[ℂ] (1 : HiggsJetAlgebra)) + = (FermionJetAlgebra.repJetGaugeGroupI U (1 : FermionJetAlgebra)) ⊗ₜ[ℂ] + (HiggsJetAlgebra.repJetGaugeGroupI U (1 : HiggsJetAlgebra)) from rfl, + show HiggsJetAlgebra.repJetGaugeGroupI U (1 : HiggsJetAlgebra) = 1 from + BosonicAlgebra.repJetGaugeGroupI_apply_one _ _ U, + show FermionJetAlgebra.repJetGaugeGroupI U (1 : FermionJetAlgebra) = 1 from + FermionicAlgebra.repJetGaugeGroupI_apply_one _ _ U, + includeGauge_apply] + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/Invariants.lean b/Physlib/Particles/StandardModel/JetAlgebra/Invariants.lean new file mode 100644 index 000000000..da38feb46 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/Invariants.lean @@ -0,0 +1,194 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.JetAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.JetAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.Invariants +/-! +# Gauge invariants of the jet algebra of the Standard Model + +## i. Overview + +The jet algebra of the Standard Model, with its Lorentz action, jet gauge action, the +gauge-field generators included from the gauge sector, and the total derivative, is a +*gauge field* in the sense of the abstract covariance machinery of +`Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued`. This file establishes that +instance and instantiates the abstract classification of invariants on the full algebra: + +**a gauge-invariant element of the subalgebra generated by the gauge-field symbols +`∂_s A_μ^φ` — together with any set `S` of elements fixed by the pure jets, such as the +covariant towers of the fermion and Higgs fields — is a polynomial in the covariant +derivatives of the field strength and the elements of `S`.** + +This is the covariance reduction of the Standard Model jet algebra: gauge invariance +eliminates the bare gauge-field symbols in favour of field strengths and covariant +derivatives. + +## ii. Key results + +- `JetAlgebra.gaugeField` : the gauge-field generators inside the full jet algebra. +- `JetAlgebra.isGaugeField` : the jet algebra of the Standard Model is a gauge field. +- `JetAlgebra.invariant_mem_adjoin_fieldStrength` : the classification of gauge + invariants. + +## iii. Table of contents + +- A. The gauge field inside the jet algebra + - A.1. The gauge-field generators + - A.2. Iterated derivatives through the gauge inclusion + - A.3. Centrality +- B. The `IsGaugeField` instance +- C. The classification of gauge invariants + +-/ + +@[expose] public section + +set_option maxHeartbeats 4000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +namespace JetAlgebra + +open TensorProduct Matrix MatrixGroups + +/-! + +## A. The gauge field inside the jet algebra + +-/ + +/-! + +### A.1. The gauge-field generators + +-/ + +/-- The gauge-field derivative symbols of the jet algebra of the Standard Model: the + gauge sector's symbols, included into the full algebra. -/ +noncomputable def gaugeField (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) : + Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] JetAlgebra where + toFun φ := includeGauge (GaugeJetAlgebra.gaugeField s μ φ) + map_add' φ ψ := by rw [map_add, map_add] + map_smul' r φ := by + rw [map_smul, ← algebraMap_smul ℂ r (GaugeJetAlgebra.gaugeField s μ φ), map_smul, + algebraMap_smul, RingHom.id_apply] + +@[simp] +lemma gaugeField_apply (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra) : + gaugeField s μ φ = includeGauge (GaugeJetAlgebra.gaugeField s μ φ) := rfl + +/-! + +### A.2. Iterated derivatives through the gauge inclusion + +-/ + +/-- The iterated total derivative acts on the gauge sector through the gauge sector's + own iterated derivative. -/ +lemma iteratedD_includeGauge (s : Multiset (Fin 1 ⊕ Fin 3)) + (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + Lorentz.iteratedD jetDeriv jetDeriv_comm s (includeGauge y) + = includeGauge (Lorentz.iteratedD GaugeJetAlgebra.complexJetDeriv + GaugeJetAlgebra.complexJetDeriv_comm s y) := by + induction s using Multiset.induction_on with + | empty => + rw [Lorentz.iteratedD_zero, Lorentz.iteratedD_zero, LinearMap.id_apply, + LinearMap.id_apply] + | cons κ s ih => + rw [Lorentz.iteratedD_cons, Lorentz.iteratedD_cons, LinearMap.comp_apply, + LinearMap.comp_apply, ih, jetDeriv_includeGauge] + +/-! + +### A.3. Centrality + +-/ + +/-- The gauge sector lands in the centre of the jet algebra. -/ +lemma includeGauge_mem_center (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + includeGauge y ∈ Subring.center JetAlgebra := + Subring.mem_center_iff.mpr fun z => includeGauge_commute y z + +/-! + +## B. The `IsGaugeField` instance + +-/ + +/-- **The jet algebra of the Standard Model is a gauge field**: its gauge-field + derivative symbols are those of a Lorentz covector, transform under the jet gauge + group by the all-orders Leibniz convolution of the adjoint Taylor coefficients plus + the Maurer–Cartan shift, and the gauge action is multiplicative. All three laws + transport from the gauge sector through the central inclusion. -/ +theorem isGaugeField : + IsGaugeField (B := JetAlgebra) repLorentzGroup repJetGaugeGroupI gaugeField where + lorentz_apply Λ n l μ φ := + (repLorentzGroup_includeGauge Λ + (GaugeJetAlgebra.gaugeField (List.ofFn l) μ φ)).trans <| + (congrArg includeGauge + (GaugeJetAlgebra.isGaugeField.lorentz_apply Λ n l μ φ)).trans <| + (map_sum includeGauge _ Finset.univ).trans <| + Finset.sum_congr rfl fun p _ => + (map_smul includeGauge _ _).trans <| + congrArg (HSMul.hSMul _) <| + (map_sum includeGauge _ Finset.univ).trans <| + Finset.sum_congr rfl fun a _ => map_smul includeGauge _ _ + gauge_apply_deriv U s μ φ := + (repJetGaugeGroupI_includeGauge U _).trans <| + (congrArg includeGauge + (GaugeJetAlgebra.isGaugeField.gauge_apply_deriv U s μ φ)).trans <| by + rw [map_add, map_multiset_sum, Multiset.map_map, AlgHom.commutes] + exact congrArg₂ (· + ·) + (congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => rfl)) rfl + gauge_mul U b₁ b₂ := repJetGaugeGroupI_apply_mul U b₁ b₂ + +/-! + +## C. The classification of gauge invariants + +-/ + +/-- **The classification of gauge invariants of the jet algebra of the Standard Model**: + a gauge-invariant element of the subalgebra generated by the gauge-field symbols + `∂_s A_μ^φ` and a set `S` of elements fixed by the pure jets — such as the covariant + towers of the fermion and Higgs fields — is a polynomial in the covariant derivatives + of the field strength and the elements of `S`. + + This is the covariance reduction of the Standard Model jet algebra: gauge invariance + eliminates the bare gauge-field symbols in favour of the field strength, its covariant + derivatives, and the matter content `S`. -/ +theorem invariant_mem_adjoin_fieldStrength (S : Set JetAlgebra) + (hS : ∀ y ∈ S, ∀ U : JetGaugeGroupI.truncationKer 0, repJetGaugeGroupI U.1 y = y) + {x : JetAlgebra} + (hx : x ∈ Algebra.adjoin ℂ ({b : JetAlgebra | + ∃ (p : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = gaugeField p μ φ} ∪ S)) + (hinv : ∀ U : JetGaugeGroupI, repJetGaugeGroupI U x = x) : + x ∈ Algebra.adjoin ℂ ({b : JetAlgebra | + ∃ (l : List (Fin 1 ⊕ Fin 3)) (ν lam : Fin 1 ⊕ Fin 3) + (φ : Module.Dual ℝ GaugeAlgebra), + b = IsGaugeField.iteratedCovDerivAdjoint gaugeField l + (IsGaugeField.fieldStrength gaugeField ν lam) 0 φ} ∪ S) := + IsGaugeField.invariant_mem_adjoin_fieldStrength isGaugeField + (fun p q μ ν φ ψ => + Subring.mem_center_iff.mp + (includeGauge_mem_center (GaugeJetAlgebra.gaugeField q ν ψ)) _) + S + (fun p μ φ y _ => + Subring.mem_center_iff.mp + (includeGauge_mem_center (GaugeJetAlgebra.gaugeField p μ φ)) y) + hS hx hinv + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean b/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean new file mode 100644 index 000000000..73e5ef88b --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean @@ -0,0 +1,284 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.JetDeriv +/-! +# The total derivative on the jet algebra of the Standard Model + +## i. Overview + +The formal total derivative on the jet algebra of the Standard Model is the sum of the +total derivatives of the three sector algebras, each acting on its own tensor factor. It +obeys the Leibniz rule, its components commute, and it restricts to the gauge sector's own +derivative through the sector inclusion. + +The Leibniz rule and the commutation are assembled from the sector facts through abstract +lemmas proved at small types, instantiated in term mode — rewriting inside the full tensor +product is prohibitively slow. + +## ii. Key results + +- `JetAlgebra.jetDeriv` : the formal total derivative. +- `JetAlgebra.jetDeriv_mul` : the Leibniz rule. +- `JetAlgebra.jetDeriv_comm` : the total derivatives commute. +- `JetAlgebra.jetDeriv_includeGauge` : the restriction to the gauge sector. + +## iii. Table of contents + +- A. The formal total derivative + - A.1. The action on pure tensors and the gauge sector +- B. Derivations on tensor products +- C. The Leibniz rule +- D. Commutativity + +-/ + +@[expose] public section + +set_option maxHeartbeats 8000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +namespace JetAlgebra + +/-! + +## A. The formal total derivative + +-/ + +/-- **The formal total derivative on the jet algebra of the Standard Model**: the sum of + the total derivatives of the three sectors, each acting on its own factor. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : JetAlgebra →ₗ[ℂ] JetAlgebra := + TensorProduct.map (TensorProduct.map (FermionicAlgebra.jetDeriv μ) LinearMap.id) + LinearMap.id + + TensorProduct.map (TensorProduct.map LinearMap.id (BosonicAlgebra.jetDeriv μ)) + LinearMap.id + + TensorProduct.map LinearMap.id (GaugeJetAlgebra.complexJetDeriv μ) + +/-! + +### A.1. The action on pure tensors and the gauge sector + +-/ + +lemma jetDeriv_tmul (μ : Fin 1 ⊕ Fin 3) (f : FermionJetAlgebra) (h : HiggsJetAlgebra) + (g : ℂ ⊗[ℝ] GaugeJetAlgebra) : + jetDeriv μ ((f ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] g) + = ((FermionicAlgebra.jetDeriv μ f) ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] g + + (f ⊗ₜ[ℂ] (BosonicAlgebra.jetDeriv μ h)) ⊗ₜ[ℂ] g + + (f ⊗ₜ[ℂ] h) ⊗ₜ[ℂ] (GaugeJetAlgebra.complexJetDeriv μ g) := rfl + +/-- The derivative acts on the gauge sector through the gauge sector's own derivative. -/ +lemma jetDeriv_includeGauge (μ : Fin 1 ⊕ Fin 3) (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + jetDeriv μ (includeGauge y) = includeGauge (GaugeJetAlgebra.complexJetDeriv μ y) := by + rw [includeGauge_apply, jetDeriv_tmul, + show FermionicAlgebra.jetDeriv (V := FermionSpace) μ (1 : FermionJetAlgebra) = 0 from + FermionicAlgebra.jetDeriv_one μ, + show BosonicAlgebra.jetDeriv (V := HiggsVec) μ (1 : HiggsJetAlgebra) = 0 from + BosonicAlgebra.jetDeriv_one μ, + TensorProduct.zero_tmul, TensorProduct.zero_tmul, TensorProduct.tmul_zero, + TensorProduct.zero_tmul, zero_add, zero_add, includeGauge_apply] + +/-! + +## B. Derivations on tensor products + +-/ + +/-- A derivation of the left factor extends to a derivation of the tensor product. -/ +lemma _root_.TensorProduct.map_derivation_left {A B : Type*} [Ring A] [Algebra ℂ A] + [Ring B] [Algebra ℂ B] (D : A →ₗ[ℂ] A) + (hD : ∀ x y, D (x * y) = D x * y + x * D y) (x y : A ⊗[ℂ] B) : + TensorProduct.map D LinearMap.id (x * y) + = TensorProduct.map D LinearMap.id x * y + + x * TensorProduct.map D LinearMap.id y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => + rw [add_mul, map_add, map_add, h₁, h₂, add_mul, add_mul] + abel + | tmul a₁ b₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => + rw [mul_add, map_add, map_add, h₁, h₂, mul_add, mul_add] + abel + | tmul a₂ b₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, TensorProduct.map_tmul, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, LinearMap.id_apply, hD, TensorProduct.add_tmul, + Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul] + +/-- A derivation of the right factor extends to a derivation of the tensor product. -/ +lemma _root_.TensorProduct.map_derivation_right {A B : Type*} [Ring A] [Algebra ℂ A] + [Ring B] [Algebra ℂ B] (D : B →ₗ[ℂ] B) + (hD : ∀ x y, D (x * y) = D x * y + x * D y) (x y : A ⊗[ℂ] B) : + TensorProduct.map LinearMap.id D (x * y) + = TensorProduct.map LinearMap.id D x * y + + x * TensorProduct.map LinearMap.id D y := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x₁ x₂ h₁ h₂ => + rw [add_mul, map_add, map_add, h₁, h₂, add_mul, add_mul] + abel + | tmul a₁ b₁ => + induction y using TensorProduct.induction_on with + | zero => simp + | add y₁ y₂ h₁ h₂ => + rw [mul_add, map_add, map_add, h₁, h₂, mul_add, mul_add] + abel + | tmul a₂ b₂ => + rw [Algebra.TensorProduct.tmul_mul_tmul, TensorProduct.map_tmul, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, LinearMap.id_apply, hD, TensorProduct.tmul_add, + Algebra.TensorProduct.tmul_mul_tmul, Algebra.TensorProduct.tmul_mul_tmul] + +/-! + +## C. The Leibniz rule + +-/ + +/-- The sum of three derivations is a derivation: the purely additive assembly, stated + abstractly so it can be instantiated without rewriting inside a large type. -/ +private lemma add₃_derivation {R : Type*} [NonUnitalNonAssocRing R] + {D₁ D₂ D₃ : R → R} {x y : R} + (h₁ : D₁ (x * y) = D₁ x * y + x * D₁ y) + (h₂ : D₂ (x * y) = D₂ x * y + x * D₂ y) + (h₃ : D₃ (x * y) = D₃ x * y + x * D₃ y) : + D₁ (x * y) + D₂ (x * y) + D₃ (x * y) + = (D₁ x + D₂ x + D₃ x) * y + x * (D₁ y + D₂ y + D₃ y) := by + rw [h₁, h₂, h₃, add_mul, add_mul, mul_add, mul_add] + abel + +/-- **The Leibniz rule** for the total derivative on the jet algebra. -/ +lemma jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) (x y : JetAlgebra) : + jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y := by + have h₁ := TensorProduct.map_derivation_left + (B := ℂ ⊗[ℝ] GaugeJetAlgebra) + (TensorProduct.map (FermionicAlgebra.jetDeriv μ) LinearMap.id) + (TensorProduct.map_derivation_left (FermionicAlgebra.jetDeriv μ) + (FermionicAlgebra.jetDeriv_mul μ)) x y + have h₂ := TensorProduct.map_derivation_left + (B := ℂ ⊗[ℝ] GaugeJetAlgebra) + (TensorProduct.map LinearMap.id (BosonicAlgebra.jetDeriv μ)) + (TensorProduct.map_derivation_right (BosonicAlgebra.jetDeriv μ) + (BosonicAlgebra.jetDeriv_mul μ)) x y + have h₃ := TensorProduct.map_derivation_right + (A := FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) + (GaugeJetAlgebra.complexJetDeriv μ) + (GaugeJetAlgebra.complexJetDeriv_mul μ) x y + exact add₃_derivation h₁ h₂ h₃ + +/-! + +## D. Commutativity + +-/ + +/-- The sum of three maps pairwise commuting with the sum of three others commutes with + it: the purely additive assembly, stated abstractly so it can be instantiated without + rewriting inside a large type. -/ +private lemma add₃_comp_comm {M : Type*} [AddCommMonoid M] [Module ℂ M] + {A₁ A₂ A₃ B₁ B₂ B₃ : M →ₗ[ℂ] M} + (h11 : A₁.comp B₁ = B₁.comp A₁) (h12 : A₁.comp B₂ = B₂.comp A₁) + (h13 : A₁.comp B₃ = B₃.comp A₁) (h21 : A₂.comp B₁ = B₁.comp A₂) + (h22 : A₂.comp B₂ = B₂.comp A₂) (h23 : A₂.comp B₃ = B₃.comp A₂) + (h31 : A₃.comp B₁ = B₁.comp A₃) (h32 : A₃.comp B₂ = B₂.comp A₃) + (h33 : A₃.comp B₃ = B₃.comp A₃) : + (A₁ + A₂ + A₃).comp (B₁ + B₂ + B₃) = (B₁ + B₂ + B₃).comp (A₁ + A₂ + A₃) := by + simp only [LinearMap.add_comp, LinearMap.comp_add, h11, h12, h13, h21, h22, h23, h31, + h32, h33] + abel + +/-- The total derivatives on the jet algebra commute. -/ +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv μ).comp (jetDeriv ν) = (jetDeriv ν).comp (jetDeriv μ) := by + have hW : ∀ D D' : (FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) →ₗ[ℂ] + (FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra), + (TensorProduct.map D (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra))).comp + (TensorProduct.map D' LinearMap.id) + = TensorProduct.map (D.comp D') LinearMap.id := fun D D' => by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + have hG : ∀ D D' : (ℂ ⊗[ℝ] GaugeJetAlgebra) →ₗ[ℂ] (ℂ ⊗[ℝ] GaugeJetAlgebra), + (TensorProduct.map (LinearMap.id (M := FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra)) + D).comp (TensorProduct.map LinearMap.id D') + = TensorProduct.map LinearMap.id (D.comp D') := fun D D' => by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + have hWG : ∀ (D : (FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) →ₗ[ℂ] + (FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra)) + (D' : (ℂ ⊗[ℝ] GaugeJetAlgebra) →ₗ[ℂ] (ℂ ⊗[ℝ] GaugeJetAlgebra)), + (TensorProduct.map D LinearMap.id).comp (TensorProduct.map LinearMap.id D') + = (TensorProduct.map LinearMap.id D').comp (TensorProduct.map D LinearMap.id) := + fun D D' => by + rw [← TensorProduct.map_comp, ← TensorProduct.map_comp, LinearMap.id_comp, + LinearMap.id_comp, LinearMap.comp_id, LinearMap.comp_id] + have hFH : ∀ (D : FermionJetAlgebra →ₗ[ℂ] FermionJetAlgebra) + (D' : HiggsJetAlgebra →ₗ[ℂ] HiggsJetAlgebra), + (TensorProduct.map D LinearMap.id).comp (TensorProduct.map LinearMap.id D') + = (TensorProduct.map LinearMap.id D').comp (TensorProduct.map D LinearMap.id) := + fun D D' => by + rw [← TensorProduct.map_comp, ← TensorProduct.map_comp, LinearMap.id_comp, + LinearMap.id_comp, LinearMap.comp_id, LinearMap.comp_id] + have hFF : ∀ D D' : FermionJetAlgebra →ₗ[ℂ] FermionJetAlgebra, + (TensorProduct.map D (LinearMap.id (M := HiggsJetAlgebra))).comp + (TensorProduct.map D' LinearMap.id) + = TensorProduct.map (D.comp D') LinearMap.id := fun D D' => by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + have hHH : ∀ D D' : HiggsJetAlgebra →ₗ[ℂ] HiggsJetAlgebra, + (TensorProduct.map (LinearMap.id (M := FermionJetAlgebra)) D).comp + (TensorProduct.map LinearMap.id D') + = TensorProduct.map LinearMap.id (D.comp D') := fun D D' => by + rw [← TensorProduct.map_comp, LinearMap.id_comp] + have h11 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra))) + ((hFF _ _).trans + ((congrArg (fun d => TensorProduct.map d (LinearMap.id (M := HiggsJetAlgebra))) + (FermionicAlgebra.jetDeriv_comm μ ν)).trans (hFF _ _).symm))).trans + (hW _ _).symm) + have h22 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra))) + ((hHH _ _).trans + ((congrArg (fun d => TensorProduct.map (LinearMap.id (M := FermionJetAlgebra)) d) + (BosonicAlgebra.jetDeriv_comm μ ν)).trans (hHH _ _).symm))).trans + (hW _ _).symm) + have h33 := (hG _ _).trans + ((congrArg (fun d => TensorProduct.map + (LinearMap.id (M := FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra)) d) + (GaugeJetAlgebra.complexJetDeriv_comm μ ν)).trans (hG _ _).symm) + have h12 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra))) + (hFH (FermionicAlgebra.jetDeriv μ) (BosonicAlgebra.jetDeriv ν))).trans + (hW _ _).symm) + have h21 := (hW _ _).trans + ((congrArg (fun m => TensorProduct.map m (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra))) + (hFH (FermionicAlgebra.jetDeriv ν) (BosonicAlgebra.jetDeriv μ)).symm).trans + (hW _ _).symm) + exact add₃_comp_comm h11 h12 (hWG _ _) h21 h22 (hWG _ _) (hWG _ _).symm + (hWG _ _).symm h33 + +/-! + +## The iterated derivative + +-/ + +TODO "Define the iterated derivative, and show that the iterated derivatives span + the adjoin to give the whole algebra." + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/LorentzAction.lean b/Physlib/Particles/StandardModel/JetAlgebra/LorentzAction.lean new file mode 100644 index 000000000..571ee8db5 --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/LorentzAction.lean @@ -0,0 +1,196 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.JetAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.LorentzAction +/-! +# The Lorentz action on the jet algebra of the Standard Model + +## i. Overview + +The Lorentz group acts on the jet algebra of the Standard Model sector by sector: the +tensor product of the fermionic, Higgs and complexified gauge-boson actions. The action is +multiplicative, restricts to the gauge sector's own action through the sector inclusion, +and intertwines the total derivative through the columns of the Lorentz matrix — the +total derivative is a Lorentz vector, packaged as a `Lorentz.IsLorentzDeriv` instance. + +The covariance of the derivative is assembled from the sector facts through an abstract +two-factor lemma proved at small types, instantiated in term mode — rewriting inside the +full tensor product is prohibitively slow. + +## ii. Key results + +- `JetAlgebra.repLorentzGroup` : the Lorentz action. +- `JetAlgebra.repLorentzGroup_apply_mul` : the action is multiplicative. +- `JetAlgebra.repLorentzGroup_includeGauge` : the restriction to the gauge sector. +- `JetAlgebra.repLorentzGroup_jetDeriv`, `JetAlgebra.instIsLorentzDeriv` : the total + derivative is a Lorentz vector. + +## iii. Table of contents + +- A. The action of the Lorentz group + - A.1. Multiplicativity + - A.2. The action on the gauge sector +- B. The total derivative is a Lorentz vector + +-/ + +@[expose] public section + +set_option maxHeartbeats 8000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct Matrix MatrixGroups + +namespace JetAlgebra + +/-! + +## A. The action of the Lorentz group + +-/ + +/-- The Lorentz action on the jet algebra of the Standard Model: the three sectors + transform independently. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) JetAlgebra := + (FermionJetAlgebra.repLorentzGroup.tprod HiggsJetAlgebra.repLorentzGroup).tprod + GaugeJetAlgebra.complexRepLorentzGroup + +@[simp] +lemma repLorentzGroup_tmul (Λ : SL(2,ℂ)) (w : FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra) + (g : ℂ ⊗[ℝ] GaugeJetAlgebra) : + repLorentzGroup Λ (w ⊗ₜ[ℂ] g) + = ((FermionJetAlgebra.repLorentzGroup.tprod HiggsJetAlgebra.repLorentzGroup) Λ w) + ⊗ₜ[ℂ] (GaugeJetAlgebra.complexRepLorentzGroup Λ g) := rfl + +/-! + +### A.1. Multiplicativity + +-/ + +/-- The Lorentz action on the jet algebra is multiplicative. -/ +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (x y : JetAlgebra) : + repLorentzGroup Λ (x * y) = repLorentzGroup Λ x * repLorentzGroup Λ y := + Representation.tprod_apply_mul _ _ + (Representation.tprod_apply_mul _ _ + (FermionicAlgebra.repLorentzGroup_apply_mul _) + (BosonicAlgebra.repLorentzGroup_apply_mul _)) + GaugeJetAlgebra.complexRepLorentzGroup_apply_mul Λ x y + +/-! + +### A.2. The action on the gauge sector + +-/ + +/-- The Lorentz action restricts to the gauge sector's own action. -/ +lemma repLorentzGroup_includeGauge (Λ : SL(2,ℂ)) (y : ℂ ⊗[ℝ] GaugeJetAlgebra) : + repLorentzGroup Λ (includeGauge y) + = includeGauge (GaugeJetAlgebra.complexRepLorentzGroup Λ y) := by + rw [includeGauge_apply, repLorentzGroup_tmul, + show (FermionJetAlgebra.repLorentzGroup.tprod HiggsJetAlgebra.repLorentzGroup) Λ + ((1 : FermionJetAlgebra) ⊗ₜ[ℂ] (1 : HiggsJetAlgebra)) + = (FermionJetAlgebra.repLorentzGroup Λ (1 : FermionJetAlgebra)) ⊗ₜ[ℂ] + (HiggsJetAlgebra.repLorentzGroup Λ (1 : HiggsJetAlgebra)) from rfl, + show HiggsJetAlgebra.repLorentzGroup Λ (1 : HiggsJetAlgebra) = 1 from + BosonicAlgebra.repLorentzGroup_apply_one _ Λ, + show FermionJetAlgebra.repLorentzGroup Λ (1 : FermionJetAlgebra) = 1 from + FermionicAlgebra.repLorentzGroup_apply_one _ Λ, + includeGauge_apply] + +/-! + +## B. The total derivative is a Lorentz vector + +-/ + +/-- A factorwise sum of Lorentz-vector derivatives on a tensor product is a Lorentz + vector: the abstract two-factor assembly, proved by tensor induction at abstract types + so that it can be instantiated on the jet algebra without rewriting inside it. -/ +private lemma tprod_deriv_sum {M N : Type} [AddCommGroup M] [Module ℂ M] + [AddCommGroup N] [Module ℂ N] + (ρ : Representation ℂ SL(2,ℂ) M) (σ : Representation ℂ SL(2,ℂ) N) + (D : (Fin 1 ⊕ Fin 3) → M →ₗ[ℂ] M) (E : (Fin 1 ⊕ Fin 3) → N →ₗ[ℂ] N) + (c : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → ℂ) (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (hD : ∀ ν x, ρ Λ (D ν x) = ∑ a, c a ν • D a (ρ Λ x)) + (hE : ∀ ν x, σ Λ (E ν x) = ∑ a, c a ν • E a (σ Λ x)) (x : M ⊗[ℂ] N) : + (ρ.tprod σ) Λ + ((TensorProduct.map (D μ) (LinearMap.id (M := N)) + + TensorProduct.map (LinearMap.id (M := M)) (E μ)) x) + = ∑ a, c a μ • + (TensorProduct.map (D a) (LinearMap.id (M := N)) + + TensorProduct.map (LinearMap.id (M := M)) (E a)) + ((ρ.tprod σ) Λ x) := by + induction x using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => + rw [map_add, map_add, map_add, hx, hy, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + | tmul m n => + rw [LinearMap.add_apply, TensorProduct.map_tmul, TensorProduct.map_tmul, + LinearMap.id_apply, LinearMap.id_apply, map_add, + show (ρ.tprod σ) Λ ((D μ m) ⊗ₜ[ℂ] n) = (ρ Λ (D μ m)) ⊗ₜ[ℂ] (σ Λ n) from rfl, + show (ρ.tprod σ) Λ (m ⊗ₜ[ℂ] (E μ n)) = (ρ Λ m) ⊗ₜ[ℂ] (σ Λ (E μ n)) from rfl, + hD, hE, TensorProduct.sum_tmul, TensorProduct.tmul_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun a _ => ?_ + rw [LinearMap.add_apply, + show (ρ.tprod σ) Λ (m ⊗ₜ[ℂ] n) = (ρ Λ m) ⊗ₜ[ℂ] (σ Λ n) from rfl, + TensorProduct.map_tmul, TensorProduct.map_tmul, LinearMap.id_apply, + LinearMap.id_apply, smul_add, ← TensorProduct.smul_tmul', + TensorProduct.tmul_smul] + +/-- **The total derivative on the jet algebra is a Lorentz vector.** -/ +lemma repLorentzGroup_jetDeriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (x : JetAlgebra) : + repLorentzGroup Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup Λ x) := by + have e : ∀ ν, TensorProduct.map + (TensorProduct.map (FermionicAlgebra.jetDeriv ν) LinearMap.id + + TensorProduct.map LinearMap.id (BosonicAlgebra.jetDeriv ν)) + (LinearMap.id (M := ℂ ⊗[ℝ] GaugeJetAlgebra)) + + TensorProduct.map LinearMap.id (GaugeJetAlgebra.complexJetDeriv ν) + = jetDeriv ν := fun ν => + congrArg (fun m => m + TensorProduct.map LinearMap.id + (GaugeJetAlgebra.complexJetDeriv ν)) (TensorProduct.map_add_left _ _ _) + have hFH : ∀ (ν : Fin 1 ⊕ Fin 3) (w : FermionJetAlgebra ⊗[ℂ] HiggsJetAlgebra), + (FermionJetAlgebra.repLorentzGroup.tprod HiggsJetAlgebra.repLorentzGroup) Λ + ((TensorProduct.map (FermionicAlgebra.jetDeriv (V := FermionSpace) ν) + (LinearMap.id (M := HiggsJetAlgebra)) + + TensorProduct.map (LinearMap.id (M := FermionJetAlgebra)) + (BosonicAlgebra.jetDeriv (V := HiggsVec) ν)) w) + = ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a ν : ℝ) : ℂ) • + (TensorProduct.map (FermionicAlgebra.jetDeriv (V := FermionSpace) a) + (LinearMap.id (M := HiggsJetAlgebra)) + + TensorProduct.map (LinearMap.id (M := FermionJetAlgebra)) + (BosonicAlgebra.jetDeriv (V := HiggsVec) a)) + ((FermionJetAlgebra.repLorentzGroup.tprod + HiggsJetAlgebra.repLorentzGroup) Λ w) := fun ν w => + tprod_deriv_sum _ _ _ _ _ Λ ν + (fun κ z => FermionicAlgebra.repLorentzGroup_jetDeriv _ Λ κ z) + (fun κ z => BosonicAlgebra.repLorentzGroup_jetDeriv _ Λ κ z) w + refine (congrArg (fun (L : JetAlgebra →ₗ[ℂ] JetAlgebra) => repLorentzGroup Λ (L x)) + (e μ).symm).trans ((tprod_deriv_sum _ _ _ _ _ Λ μ hFH + (fun κ z => GaugeJetAlgebra.complexRepLorentzGroup_jetDeriv Λ κ z) x).trans + (Finset.sum_congr rfl fun a _ => congrArg + (fun (L : JetAlgebra →ₗ[ℂ] JetAlgebra) => + (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • L (repLorentzGroup Λ x)) + (e a))) + +/-- The total derivatives on the jet algebra form a Lorentz derivative. -/ +instance instIsLorentzDeriv : Lorentz.IsLorentzDeriv repLorentzGroup jetDeriv where + rep_deriv := repLorentzGroup_jetDeriv _ _ _ + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/JetAlgebra/MassDim.lean b/Physlib/Particles/StandardModel/JetAlgebra/MassDim.lean new file mode 100644 index 000000000..dc047a53e --- /dev/null +++ b/Physlib/Particles/StandardModel/JetAlgebra/MassDim.lean @@ -0,0 +1,68 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.JetAlgebra.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.GaugeJetAlgebra.MassDim +/-! +# The mass-dimension scaling on the jet algebra of the Standard Model + +## i. Overview + +The mass-dimension scaling on the jet algebra of the Standard Model acts sector by +sector: fermions carry mass weight three, the Higgs weight two, the gauge fields weight +two, and every derivative weight two. A monomial of total mass weight `w` is scaled by +`r ^ w`; the terms of a Lagrangian of mass dimension four are exactly those scaling with +`r ^ 8`. + +## ii. Key results + +- `JetAlgebra.complexGaugeMassWeightScale` : the scaling on the complexified gauge + sector. +- `JetAlgebra.massWeightScale` : the mass-dimension scaling on the jet algebra. + +## iii. Table of contents + +- A. The mass-dimension scaling + +-/ + +@[expose] public section + +set_option maxHeartbeats 8000000 +set_option synthInstance.maxHeartbeats 1000000 +set_option synthInstance.maxSize 2048 +set_option maxRecDepth 8000 + +namespace StandardModel + +open TensorProduct + +namespace JetAlgebra + +/-! + +## A. The mass-dimension scaling + +-/ + +/-- The mass-dimension scaling on the complexified gauge sector. -/ +noncomputable def complexGaugeMassWeightScale (r : ℝ) : + (ℂ ⊗[ℝ] GaugeJetAlgebra) →ₐ[ℂ] (ℂ ⊗[ℝ] GaugeJetAlgebra) := + Algebra.TensorProduct.map (AlgHom.id ℂ ℂ) (GaugeJetAlgebra.massWeightScale r) + +/-- **The mass-dimension scaling on the jet algebra of the Standard Model**: each sector + scales by its own mass weights — fermions carry weight three, the Higgs weight two, the + gauge fields weight two, and every derivative weight two. -/ +noncomputable def massWeightScale (r : ℝ) : JetAlgebra →ₐ[ℂ] JetAlgebra := + Algebra.TensorProduct.map + (Algebra.TensorProduct.map (FermionJetAlgebra.massWeightScale (r : ℂ)) + (HiggsJetAlgebra.massWeightScale (r : ℂ))) + (complexGaugeMassWeightScale r) + +end JetAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Basic.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Basic.lean new file mode 100644 index 000000000..625eddffb --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Basic.lean @@ -0,0 +1,183 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic +public import Physlib.Mathematics.SymmetricAlgebra +/-! +# The bosonic algebra of a matter field + +## i. Overview + +For a bosonic matter field valued in a complex vector space `V`, the *bosonic algebra* is +the symmetric algebra on the jet component space `JetComponentSpace V`. It is the algebra +in which the `V`-part of a Lagrangian lives: the generators are the component functions +`∂_s φ_α` and their conjugates `∂_s φ̄_α`, and the symmetric product implements the +commutativity of bosonic fields. It is the bosonic mirror of `FermionicAlgebra`, with the +symmetric algebra in place of the exterior algebra. + +Everything the component space carries lifts to the bosonic algebra by functoriality of +the symmetric algebra: the Lorentz action (`BosonicAlgebra.repLorentzGroup`), the jet +gauge action (`BosonicAlgebra.repJetGaugeGroupI`), and the formal total derivative +(`BosonicAlgebra.jetDeriv`), which extends as a derivation rather than by functoriality. +Those live in the sibling files `LorentzAction`, `GaugeAction` and `JetDeriv`. + +## ii. Key results + +- `BosonicAlgebra` : the symmetric algebra on the jet component space. +- `BosonicAlgebra.adjoin_ι_eq_top` : the algebra is generated by the component functions. +- `BosonicAlgebra.ofField`, `BosonicAlgebra.ofConjField` : the field and its conjugate. +- `BosonicAlgebra.comap` : the inclusion of a species, contravariant in the target space. + +## iii. Table of contents + +- A. The bosonic algebra + - A.1. The generators of the bosonic algebra + - A.2. The field and its conjugate + - A.3. Inclusion of a species + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The bosonic algebra + +-/ + +/-- The bosonic algebra of a `V`-valued matter field: the symmetric algebra on the space + of component functions `∂_s φ_α` and `∂_s φ̄_α`. The symmetric product is the product of + bosonic fields, its commutativity the Bose statistics. -/ +abbrev BosonicAlgebra (V : Type) [AddCommGroup V] [Module ℂ V] : Type := + SymmetricAlgebra ℂ (JetComponentSpace V) + +namespace BosonicAlgebra + +/-! + +### A.1. The generators of the bosonic algebra + +-/ + +/-- **The bosonic algebra is generated by the component functions.** Every element is a + polynomial in the degree-one elements — the symbols `∂_s φ_α` and `∂_s φ̄_α` themselves. + This is the algebraic form of "every Lagrangian term is a polynomial in the component + functions". -/ +@[simp] +lemma adjoin_ι_eq_top : + Algebra.adjoin ℂ (Set.range (SymmetricAlgebra.ι ℂ (JetComponentSpace V))) = ⊤ := + SymmetricAlgebra.adjoin_range_ι + +/-- Two component functions commute: Bose statistics. -/ +lemma ι_mul_ι_comm (x y : JetComponentSpace V) : + (SymmetricAlgebra.ι ℂ _ x * SymmetricAlgebra.ι ℂ _ y : BosonicAlgebra V) + = SymmetricAlgebra.ι ℂ _ y * SymmetricAlgebra.ι ℂ _ x := + mul_comm _ _ + +/-! + +### A.2. The field and its conjugate + +The undifferentiated component functions sit inside the bosonic algebra as the two +inclusions below. A component function is a *covector* on the target space: `ofField φ` is +the component of the field `ψ` along `φ`, the element written `ψ_α` when `φ` is the `α`-th +coordinate. The conjugate field is a covector on `ConjModule V`, whose scalar action is +twisted by complex conjugation — that twist is exactly the statement that `ψ̄` transforms +by the conjugate of the representation carried by `ψ`. + +Every other generator of the algebra is an iterated derivative of one of these, which is +the content of `BosonicAlgebra.adjoin_iteratedJetDeriv_eq_top`. + +-/ + +/-- **The component function `ψ_φ` of the matter field** along the covector `φ` on `V`: the + undifferentiated generator, sitting at the empty derivative label in the unconjugated half + of the component space. -/ +noncomputable def ofField : Module.Dual ℂ V →ₗ[ℂ] BosonicAlgebra V := + (SymmetricAlgebra.ι ℂ _).comp + ((LinearMap.inl ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V))).comp + (TensorProduct.mk ℂ DerivAlgebraComplex (Module.Dual ℂ V) 1)) + +/-- **The component function `ψ̄_φ` of the conjugate matter field** along the covector `φ` + on `ConjModule V`: the undifferentiated generator in the conjugate half of the component + space. -/ +noncomputable def ofConjField : Module.Dual ℂ (ConjModule V) →ₗ[ℂ] BosonicAlgebra V := + (SymmetricAlgebra.ι ℂ _).comp + ((LinearMap.inr ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V))).comp + (TensorProduct.mk ℂ DerivAlgebraComplex (Module.Dual ℂ (ConjModule V)) 1)) + +lemma ofField_apply (φ : Module.Dual ℂ V) : + ofField φ = SymmetricAlgebra.ι ℂ _ + (((1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ, 0) : JetComponentSpace V) := rfl + +lemma ofConjField_apply (φ : Module.Dual ℂ (ConjModule V)) : + ofConjField φ = SymmetricAlgebra.ι ℂ _ + ((0, (1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ) : JetComponentSpace V) := rfl + +/-! + +### A.3. Inclusion of a species + +A field valued in `V` that is one *species* among several — i.e. `V` is a summand of a +larger target space `W` — has its bosonic algebra sitting inside the bosonic algebra of +`W`. The inclusion is induced by the *projection* `W →ₗ[ℂ] V`, because component functions +are covectors on the target and therefore transpose. `comap` is that induced map, and it is +functorial and compatible with everything the algebra carries. + +-/ + +variable {W : Type} [AddCommGroup W] [Module ℂ W] + +/-- **The bosonic algebra is contravariant in the target space.** A linear map + `f : V →ₗ[ℂ] W` induces an algebra homomorphism `BosonicAlgebra W →ₐ[ℂ] BosonicAlgebra V` + by pulling back component functions. Applied to a *projection* out of a multi-species + target space, this is the inclusion of one species' algebra into the whole. -/ +noncomputable def comap (f : V →ₗ[ℂ] W) : BosonicAlgebra W →ₐ[ℂ] BosonicAlgebra V := + SymmetricAlgebra.map (JetComponentSpace.comap f) + +@[simp] +lemma comap_ι (f : V →ₗ[ℂ] W) (x : JetComponentSpace W) : + comap f (SymmetricAlgebra.ι ℂ _ x) + = SymmetricAlgebra.ι ℂ _ (JetComponentSpace.comap f x) := + SymmetricAlgebra.map_apply_ι _ x + +@[simp] +lemma comap_id : comap (LinearMap.id : V →ₗ[ℂ] V) = AlgHom.id ℂ (BosonicAlgebra V) := by + rw [comap, JetComponentSpace.comap_id, SymmetricAlgebra.map_id] + +/-- Functoriality: the order reverses, as it must for a contravariant construction. -/ +lemma comap_comp {U : Type} [AddCommGroup U] [Module ℂ U] (f : V →ₗ[ℂ] W) (g : W →ₗ[ℂ] U) : + comap (g.comp f) = (comap f).comp (comap g) := by + rw [comap, comap, comap, JetComponentSpace.comap_comp, ← SymmetricAlgebra.map_comp_map] + +/-- The inclusion sends a component function of the species to the corresponding component + function of the whole. -/ +@[simp] +lemma comap_ofField (f : V →ₗ[ℂ] W) (φ : Module.Dual ℂ W) : + comap f (ofField φ) = ofField (φ ∘ₗ f) := by + rw [ofField_apply, comap_ι, ofField_apply] + congr 1 + +/-- The inclusion sends a conjugate component function of the species to the corresponding + conjugate component function of the whole. -/ +@[simp] +lemma comap_ofConjField (f : V →ₗ[ℂ] W) (φ : Module.Dual ℂ (ConjModule W)) : + comap f (ofConjField φ) = ofConjField (φ ∘ₗ ConjModule.map f) := by + rw [ofConjField_apply, comap_ι, ofConjField_apply] + congr 1 + +end BosonicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/GaugeAction.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/GaugeAction.lean new file mode 100644 index 000000000..54f2db96b --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/GaugeAction.lean @@ -0,0 +1,241 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Basic +/-! +# The gauge action on the bosonic algebra + +## i. Overview + +Given a fibrewise action of the jet gauge group on the jets `JetRing ⊗[ℂ] V` of a bosonic +matter field, the jet gauge group acts on the bosonic algebra by the symmetric-algebra +functor applied to the induced action on the jet component space. On a component function +`∂_s φ_α` the action is the all-orders Leibniz rule: each splitting of the derivative +multiset contributes a Taylor coefficient of the gauge jet against a lower component +function. + +Restricting along `JetGaugeGroupI.ofConstant` gives the action of the constant — that is, +global — gauge transformations, which is diagonal in the derivative label. + +## ii. Key results + +- `BosonicAlgebra.repJetGaugeGroupI` : the jet gauge action on the bosonic algebra. +- `BosonicAlgebra.repJetGaugeGroupIAlgHom` : the action as an algebra homomorphism. +- `BosonicAlgebra.repJetGaugeGroupI_ofField` : `ofField` is gauge equivariant, for the + value of the gauge transformation at the base point. +- `BosonicAlgebra.repGaugeGroupI` : the action of the constant gauge transformations. + +## iii. Table of contents + +- A. The action of the jet gauge group + - A.1. Equivariance of the field and its conjugate +- B. Constant gauge transformations + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V] + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- **The jet gauge action on the bosonic algebra** of a `V`-valued matter field, induced + from a fibrewise action `rep` on the jets of the field: the symmetric-algebra functor + applied to the gauge action on the jet component space. The hypothesis `hlin` is the + statement that a gauge transformation acts on the *values* of the field, over the + identity on spacetime. -/ +noncomputable def repJetGaugeGroupI + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ JetGaugeGroupI (BosonicAlgebra V) where + toFun U := + (SymmetricAlgebra.map (JetComponentSpace.repJetGaugeGroupI rep hlin U)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, SymmetricAlgebra.map_id, AlgHom.toLinearMap_id] + map_mul' U W := by + simp only [map_mul, Module.End.mul_eq_comp, ← SymmetricAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repJetGaugeGroupI_apply + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x : BosonicAlgebra V) : + repJetGaugeGroupI rep hlin U x = + SymmetricAlgebra.map (JetComponentSpace.repJetGaugeGroupI rep hlin U) x := rfl + +@[simp] +lemma repJetGaugeGroupI_apply_one + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) : + repJetGaugeGroupI rep hlin U (1 : BosonicAlgebra V) = 1 := by + simp [repJetGaugeGroupI_apply] + +lemma repJetGaugeGroupI_apply_mul + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x y : BosonicAlgebra V) : + repJetGaugeGroupI rep hlin U (x * y) = + repJetGaugeGroupI rep hlin U x * repJetGaugeGroupI rep hlin U y := by + simp [repJetGaugeGroupI_apply] + +/-- On a component function the jet gauge action is the action on the component space. -/ +@[simp] +lemma repJetGaugeGroupI_ι + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (v : JetComponentSpace V) : + repJetGaugeGroupI rep hlin U (SymmetricAlgebra.ι ℂ _ v) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.repJetGaugeGroupI rep hlin U v) := by + rw [repJetGaugeGroupI_apply, SymmetricAlgebra.map_apply_ι] + +/-- The jet gauge action as an algebra homomorphism: a gauge transformation acts on a + Lagrangian term factor by factor. -/ +noncomputable def repJetGaugeGroupIAlgHom + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) : BosonicAlgebra V →ₐ[ℂ] BosonicAlgebra V where + toFun := repJetGaugeGroupI rep hlin U + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repJetGaugeGroupI_apply_one rep hlin U + map_mul' := repJetGaugeGroupI_apply_mul rep hlin U + commutes' r := by simp [repJetGaugeGroupI_apply] + +/-! + +### A.1. Equivariance of the field and its conjugate + +Unlike a derivative generator `∂_s φ_α`, which mixes with lower generators through the +Taylor coefficients of the gauge jet, the undifferentiated generator `φ_α` transforms by +the *value* of the gauge transformation at the base point alone. So `ofField` and +`ofConjField` are equivariant on the nose, for the contragredient of that value. + +-/ + +/-- **`ofField` is gauge equivariant.** The undifferentiated component functions transform + by the contragredient of the value of the gauge transformation at the base point; no + derivative of the gauge jet contributes. -/ +lemma repJetGaugeGroupI_ofField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (φ : Module.Dual ℂ V) : + repJetGaugeGroupI rep hlin U (ofField φ) = + ofField (Module.Dual.transpose (jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant) φ) := by + rw [ofField_apply, repJetGaugeGroupI_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · exact repDual_one_tmul rep hlin U φ + · rw [JetComponentSpace.repJetGaugeGroupI_snd] + exact map_zero _ + +/-- **`ofConjField` is gauge equivariant**, for the conjugate action `repConj rep` on the + jets of the conjugate field — which is the physicists' `φ̄ ↦ φ̄ U†`. -/ +lemma repJetGaugeGroupI_ofConjField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)) : + repJetGaugeGroupI rep hlin U (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (repConj rep U⁻¹).comp jetOfConstant) φ) := by + rw [ofConjField_apply, repJetGaugeGroupI_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repJetGaugeGroupI_fst] + exact map_zero _ + · exact repDual_one_tmul (repConj rep) (repConj_smul_comm hlin) U φ + +/-! + +## B. Constant gauge transformations + +-/ + +/-- The action of the constant — that is, global — gauge transformations on the bosonic + algebra, obtained by including a gauge transformation as a constant gauge jet. -/ +noncomputable def repGaugeGroupI + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ GaugeGroupI (BosonicAlgebra V) := + (repJetGaugeGroupI rep hlin).comp JetGaugeGroupI.ofConstant + +lemma repGaugeGroupI_apply + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (x : BosonicAlgebra V) : + repGaugeGroupI rep hlin g x = + repJetGaugeGroupI rep hlin (JetGaugeGroupI.ofConstant g) x := rfl + +@[simp] +lemma repGaugeGroupI_apply_one + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) : + repGaugeGroupI rep hlin g (1 : BosonicAlgebra V) = 1 := + repJetGaugeGroupI_apply_one rep hlin _ + +lemma repGaugeGroupI_apply_mul + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (x y : BosonicAlgebra V) : + repGaugeGroupI rep hlin g (x * y) = + repGaugeGroupI rep hlin g x * repGaugeGroupI rep hlin g y := + repJetGaugeGroupI_apply_mul rep hlin _ x y + +/-- A constant gauge transformation acts on the undifferentiated field by the + contragredient of its value — which for a constant jet is the transformation itself. -/ +lemma repGaugeGroupI_ofField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (φ : Module.Dual ℂ V) : + repGaugeGroupI rep hlin g (ofField φ) = + ofField (Module.Dual.transpose + (jetEval ∘ₗ (rep (JetGaugeGroupI.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (JetGaugeGroupI.ofConstant g)⁻¹ = JetGaugeGroupI.ofConstant g⁻¹ := + (map_inv JetGaugeGroupI.ofConstant g).symm + rw [repGaugeGroupI_apply, repJetGaugeGroupI_ofField, h] + +/-- A constant gauge transformation acts on the undifferentiated conjugate field by the + conjugate contragredient of its value. -/ +lemma repGaugeGroupI_ofConjField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)) : + repGaugeGroupI rep hlin g (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (repConj rep (JetGaugeGroupI.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (JetGaugeGroupI.ofConstant g)⁻¹ = JetGaugeGroupI.ofConstant g⁻¹ := + (map_inv JetGaugeGroupI.ofConstant g).symm + rw [repGaugeGroupI_apply, repJetGaugeGroupI_ofConjField, h] + +end BosonicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/JetDeriv.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/JetDeriv.lean new file mode 100644 index 000000000..eb8cf600a --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/JetDeriv.lean @@ -0,0 +1,332 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Basic +public import Physlib.Relativity.IsLorentzDeriv +/-! +# The formal total derivative on the bosonic algebra + +## i. Overview + +The formal total spacetime derivative extends from the component functions to the whole +bosonic algebra as a derivation: it is `SymmetricAlgebra.derivationOfLinear` applied to the +shift `∂_s φ_α ↦ ∂_{s + {μ}} φ_α` on the jet component space. + +The four directional derivatives commute, so they iterate along a *multiset* of directions +through `Lorentz.iteratedD`. On a component function the iterate is multiplication by the +derivative symbol `∂_s` in the `DerivAlgebraComplex` factor, and on a product it obeys the +all-orders Leibniz rule over the antidiagonal of the multiset. + +## ii. Key results + +- `BosonicAlgebra.jetDeriv` : the formal total spacetime derivative. +- `BosonicAlgebra.jetDeriv_mul` : the Leibniz rule. +- `BosonicAlgebra.jetDeriv_comm` : total derivatives commute. +- `BosonicAlgebra.iteratedJetDeriv` : the iterated derivative along a multiset. +- `BosonicAlgebra.iteratedJetDeriv_mul` : the all-orders Leibniz rule. +- `BosonicAlgebra.adjoin_iteratedJetDeriv_eq_top` : the algebra is generated by the field, + its conjugate, and their derivatives. +- `BosonicAlgebra.comap_jetDeriv` : the inclusion of a species commutes with the + derivative. + +## iii. Table of contents + +- A. The formal total derivative on the bosonic algebra +- B. The iterated total derivative +- C. Generation by the field and its derivatives +- D. Compatibility with the inclusion of a species + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The formal total derivative on the bosonic algebra + +-/ + +/-- The formal total spacetime derivative on the bosonic algebra of a `V`-valued matter + field in the direction `μ`: the derivation extending the shift + `∂_s φ_α ↦ ∂_{s + {μ}} φ_α` of the component functions. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : + BosonicAlgebra V →ₗ[ℂ] BosonicAlgebra V := + SymmetricAlgebra.derivationOfLinear (JetComponentSpace.jetDeriv μ) + +/-- On a component function the total derivative is the shift of the derivative label. -/ +@[simp] +lemma jetDeriv_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + jetDeriv μ (SymmetricAlgebra.ι ℂ _ x) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.jetDeriv μ x) := + SymmetricAlgebra.derivationOfLinear_ι _ x + +@[simp] +lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv (V := V) μ (1 : BosonicAlgebra V) = 0 := + SymmetricAlgebra.derivationOfLinear_one _ + +@[simp] +lemma jetDeriv_algebraMap (μ : Fin 1 ⊕ Fin 3) (r : ℂ) : + jetDeriv (V := V) μ (algebraMap ℂ (BosonicAlgebra V) r) = 0 := + SymmetricAlgebra.derivationOfLinear_algebraMap _ r + +/-- The total derivative is a derivation: the Leibniz rule holds on the bosonic + algebra. -/ +lemma jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) (x y : BosonicAlgebra V) : + jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y := + SymmetricAlgebra.derivationOfLinear_mul _ x y + +/-- **Mixed partials agree.** The derivative labels live in a *symmetric* algebra, so the + total derivatives in different directions commute. -/ +lemma jetDeriv_comm_apply (μ ν : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra V) : + jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := + SymmetricAlgebra.derivationOfLinear_comm_apply + (JetComponentSpace.jetDeriv_comm μ ν) x + +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv (V := V) μ).comp (jetDeriv ν) = (jetDeriv (V := V) ν).comp (jetDeriv μ) := + LinearMap.ext fun x => jetDeriv_comm_apply μ ν x + +/-! + +## B. The iterated total derivative + +-/ + +/-- The iterated total derivative `∂_s = ∂_{ν₁} ⋯ ∂_{νₙ}` along a multiset `s` of + directions. It is well defined on a multiset — i.e. independent of the order in which the + directions are listed — because the directional derivatives commute. -/ +noncomputable def iteratedJetDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) : + BosonicAlgebra V →ₗ[ℂ] BosonicAlgebra V := + Lorentz.iteratedD jetDeriv jetDeriv_comm s + +@[simp] +lemma iteratedJetDeriv_zero : + iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) + = LinearMap.id (R := ℂ) (M := BosonicAlgebra V) := + Lorentz.iteratedD_zero jetDeriv jetDeriv_comm + +lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (μ ::ₘ s) = (jetDeriv μ).comp (iteratedJetDeriv s) := + Lorentz.iteratedD_cons jetDeriv jetDeriv_comm μ s + +/-- The companion of `iteratedJetDeriv_cons`, peeling the extra derivative on the inside. -/ +lemma iteratedJetDeriv_cons' (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (μ ::ₘ s) = (iteratedJetDeriv s).comp (jetDeriv μ) := + Lorentz.iteratedD_cons' jetDeriv jetDeriv_comm μ s + +@[simp] +lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedJetDeriv (V := V) {μ} = jetDeriv μ := + Lorentz.iteratedD_singleton jetDeriv jetDeriv_comm μ + +/-- The iterated derivative is additive in the multiset of directions: differentiating + along `s + t` is differentiating along `t` and then along `s`. -/ +lemma iteratedJetDeriv_add (s t : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (s + t) + = (iteratedJetDeriv s).comp (iteratedJetDeriv t) := + Lorentz.iteratedD_add jetDeriv jetDeriv_comm s t + +/-- **The all-orders Leibniz rule.** The iterated derivative of a product distributes over + the antidiagonal of the multiset of directions: each way of splitting the derivatives + between the two factors contributes one term. -/ +lemma iteratedJetDeriv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (x y : BosonicAlgebra V) : + iteratedJetDeriv s (x * y) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.1 x * iteratedJetDeriv p.2 y).sum := + Lorentz.iteratedD_mul jetDeriv jetDeriv_comm jetDeriv_mul s x y + +/-- A nonempty iterated derivative kills the constants. -/ +lemma iteratedJetDeriv_one_of_ne_zero {s : Multiset (Fin 1 ⊕ Fin 3)} (hs : s ≠ 0) : + iteratedJetDeriv (V := V) s (1 : BosonicAlgebra V) = 0 := by + obtain ⟨μ, hμ⟩ := Multiset.exists_mem_of_ne_zero hs + obtain ⟨t, rfl⟩ := Multiset.exists_cons_of_mem hμ + rw [iteratedJetDeriv_cons', LinearMap.comp_apply, jetDeriv_one, map_zero] + +/-- **On a component function the iterated derivative is the derivative symbol `∂_s`.** + Both halves of the component space — the field and its conjugate — are multiplied by the + degree-`|s|` element `∂_s` of `DerivAlgebraComplex` in their derivative-label factor, + with the target index untouched. -/ +lemma iteratedJetDeriv_ι (s : Multiset (Fin 1 ⊕ Fin 3)) (x : JetComponentSpace V) : + iteratedJetDeriv s (SymmetricAlgebra.ι ℂ _ x) = + SymmetricAlgebra.ι ℂ _ + (TensorProduct.map (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis s)) + LinearMap.id x.1, + TensorProduct.map (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis s)) + LinearMap.id x.2) := by + have hmul : ∀ t u : Multiset (Fin 1 ⊕ Fin 3), + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis t)).comp + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis u)) + = LinearMap.mulRight ℂ (DerivAlgebraComplex.basis (u + t)) := fun t u => + LinearMap.ext fun a => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, mul_assoc, + DerivAlgebraComplex.basis_mul] + have hone : LinearMap.mulRight ℂ (1 : DerivAlgebraComplex) = LinearMap.id := + LinearMap.ext fun a => mul_one a + have hnil : DerivAlgebraComplex.basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := + DerivAlgebraComplex.basis_nil + induction s using Multiset.induction_on with + | empty => + rw [iteratedJetDeriv_zero, LinearMap.id_apply, hnil, hone] + simp only [TensorProduct.map_id, LinearMap.id_apply] + | cons μ s ih => + have hs : s + ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ s := by + rw [add_comm, Multiset.singleton_add] + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.jetDeriv_fst, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, hmul, hs] + · rw [JetComponentSpace.jetDeriv_snd, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, hmul, hs] + +/-! + +## C. Generation by the field and its derivatives + +-/ + +/-- The iterated derivative of the field is the generator carrying the derivative symbol + `∂_s`: applying `∂_s` to `ψ_φ` writes the label `s` into the derivative factor. -/ +@[simp] +lemma iteratedJetDeriv_ofField (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + iteratedJetDeriv s (ofField φ) = + SymmetricAlgebra.ι ℂ _ + ((DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace V) := by + rw [ofField_apply, iteratedJetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, one_mul, LinearMap.id_apply] + · rw [map_zero] + +/-- The iterated derivative of the conjugate field is the conjugate generator carrying the + derivative symbol `∂_s`. -/ +@[simp] +lemma iteratedJetDeriv_ofConjField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule V)) : + iteratedJetDeriv s (ofConjField φ) = + SymmetricAlgebra.ι ℂ _ + ((0, DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace V) := by + rw [ofConjField_apply, iteratedJetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [map_zero] + · rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, one_mul, LinearMap.id_apply] + +/-- **The bosonic algebra is generated by the field, its conjugate, and their + derivatives.** As a `ℂ`-algebra, `BosonicAlgebra V` is the algebra adjoined by the + iterated total derivatives `∂_s ψ_φ` and `∂_s ψ̄_φ` of the undifferentiated component + functions. Physically: every Lagrangian term for a `V`-valued bosonic matter field is a + polynomial in the field, its conjugate, and their spacetime derivatives — nothing else is + available to write down. -/ +theorem adjoin_iteratedJetDeriv_eq_top : + Algebra.adjoin ℂ + (⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule V) => + iteratedJetDeriv s (ofConjField φ))) + = (⊤ : Subalgebra ℂ (BosonicAlgebra V)) := by + set S : Set (BosonicAlgebra V) := + ⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule V) => + iteratedJetDeriv s (ofConjField φ)) with hS + /- The two half-inclusions of the component space into the bosonic algebra. -/ + let gField : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V →ₗ[ℂ] BosonicAlgebra V := + (SymmetricAlgebra.ι ℂ _).comp (LinearMap.inl ℂ _ _) + let gConj : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V) →ₗ[ℂ] + BosonicAlgebra V := + (SymmetricAlgebra.ι ℂ _).comp (LinearMap.inr ℂ _ _) + /- On a derivative monomial each half-inclusion is one of the adjoined generators. -/ + have hbasisField : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + gField (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gField (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) = iteratedJetDeriv s (ofField φ) := + (iteratedJetDeriv_ofField s φ).symm + rw [h, hS] + exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨s, Or.inl ⟨φ, rfl⟩⟩) + have hbasisConj : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule V)), + gConj (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gConj (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) + = iteratedJetDeriv s (ofConjField φ) := (iteratedJetDeriv_ofConjField s φ).symm + rw [h, hS] + exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨s, Or.inr ⟨φ, rfl⟩⟩) + /- The derivative monomials span, so each half-inclusion lands in the adjoined algebra. -/ + have hhalf : ∀ {W : Type} [AddCommGroup W] [Module ℂ W] + (g : DerivAlgebraComplex ⊗[ℂ] W →ₗ[ℂ] BosonicAlgebra V), + (∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (w : W), + g (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] w) ∈ Algebra.adjoin ℂ S) → + ∀ y, g y ∈ Algebra.adjoin ℂ S := by + intro W _ _ g hg y + induction y using TensorProduct.induction_on with + | zero => rw [map_zero]; exact zero_mem _ + | add y z hy hz => rw [map_add]; exact add_mem hy hz + | tmul a w => + have ha : a ∈ Submodule.span ℂ (Set.range DerivAlgebraComplex.basis) := by + rw [DerivAlgebraComplex.basis.span_eq]; trivial + induction ha using Submodule.span_induction with + | mem b hb => obtain ⟨s, rfl⟩ := hb; exact hg s w + | zero => rw [TensorProduct.zero_tmul, map_zero]; exact zero_mem _ + | add b c _ _ hb hc => rw [TensorProduct.add_tmul, map_add]; exact add_mem hb hc + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul] + exact Subalgebra.smul_mem _ hb c + /- Every component function is a sum of its two halves. -/ + refine top_le_iff.mp ?_ + rw [← adjoin_ι_eq_top (V := V)] + refine Algebra.adjoin_le ?_ + rintro _ ⟨x, rfl⟩ + have hx : x = LinearMap.inl ℂ _ _ x.1 + LinearMap.inr ℂ _ _ x.2 := by + refine Prod.ext ?_ ?_ <;> simp + rw [hx, map_add] + exact add_mem (hhalf gField hbasisField x.1) (hhalf gConj hbasisConj x.2) + +/-! + +## D. Compatibility with the inclusion of a species + +-/ + +variable {W : Type} [AddCommGroup W] [Module ℂ W] + +/-- **The inclusion of a species is a map of differential algebras.** Pulling back along a + map of target spaces commutes with the total derivative: the two act on different labels + of a component function. -/ +lemma comap_jetDeriv (f : V →ₗ[ℂ] W) (μ : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra W) : + comap f (jetDeriv μ x) = jetDeriv μ (comap f x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => + rw [jetDeriv_algebraMap, map_zero, AlgHom.commutes, jetDeriv_algebraMap] + | ι v => + rw [jetDeriv_ι, comap_ι, comap_ι, jetDeriv_ι] + exact congrArg (SymmetricAlgebra.ι ℂ _) + (DFunLike.congr_fun (JetComponentSpace.comap_jetDeriv f μ) v) + | mul a b ha hb => simp only [jetDeriv_mul, map_add, map_mul, ha, hb] + | add a b ha hb => simp only [map_add, ha, hb] + +/-- The inclusion of a species commutes with the iterated total derivative. -/ +lemma comap_iteratedJetDeriv (f : V →ₗ[ℂ] W) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : BosonicAlgebra W) : + comap f (iteratedJetDeriv s x) = iteratedJetDeriv s (comap f x) := by + induction s using Multiset.induction_on generalizing x with + | empty => rw [iteratedJetDeriv_zero, LinearMap.id_apply, iteratedJetDeriv_zero, + LinearMap.id_apply] + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, comap_jetDeriv, ih, + iteratedJetDeriv_cons, LinearMap.comp_apply] + +end BosonicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/LorentzAction.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/LorentzAction.lean new file mode 100644 index 000000000..bf3bfc44e --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/LorentzAction.lean @@ -0,0 +1,184 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +/-! +# The Lorentz action on the bosonic algebra + +## i. Overview + +Given a representation of `SL(2,ℂ)` on the target space `V` of a bosonic matter field, the +Lorentz group acts on the bosonic algebra by the symmetric-algebra functor applied to its +action on the jet component space. On a component function `∂_s φ_α` the derivative labels +transform by the Lorentz matrix and the target index contragrediently by `V`. + +The formal total derivative is a Lorentz vector for this action, which is exactly the +content of the class `Lorentz.IsLorentzDeriv`; the instance is registered here, so all the +boost-weight machinery of `Physlib.Relativity.IsLorentzDeriv` applies to the bosonic +algebra of any matter field. + +## ii. Key results + +- `BosonicAlgebra.repLorentzGroup` : the Lorentz action on the bosonic algebra. +- `BosonicAlgebra.repLorentzGroupAlgHom` : the action as an algebra homomorphism. +- `BosonicAlgebra.repLorentzGroup_ofField` : `ofField` is `SL(2,ℂ)`-equivariant. +- `BosonicAlgebra.repLorentzGroup_jetDeriv` : the total derivative is a Lorentz vector. +- `BosonicAlgebra.instIsLorentzDeriv` : the resulting `Lorentz.IsLorentzDeriv` instance. + +## iii. Table of contents + +- A. The action of the Lorentz group + - A.1. Equivariance of the field and its conjugate +- B. Lorentz covariance of the total derivative + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The action of the Lorentz group + +-/ + +/-- **The Lorentz action on the bosonic algebra** of a `V`-valued matter field, induced + from a representation `repV` of `SL(2,ℂ)` on `V`: the symmetric-algebra functor applied + to the Lorentz action on the jet component space. -/ +noncomputable def repLorentzGroup (repV : Representation ℂ SL(2,ℂ) V) : + Representation ℂ SL(2,ℂ) (BosonicAlgebra V) where + toFun Λ := (SymmetricAlgebra.map (JetComponentSpace.repLorentzGroup repV Λ)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, SymmetricAlgebra.map_id, AlgHom.toLinearMap_id] + map_mul' Λ₁ Λ₂ := by + simp only [map_mul, Module.End.mul_eq_comp, ← SymmetricAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repLorentzGroup_apply (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (x : BosonicAlgebra V) : + repLorentzGroup repV Λ x = + SymmetricAlgebra.map (JetComponentSpace.repLorentzGroup repV Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) : + repLorentzGroup repV Λ (1 : BosonicAlgebra V) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (x y : BosonicAlgebra V) : + repLorentzGroup repV Λ (x * y) + = repLorentzGroup repV Λ x * repLorentzGroup repV Λ y := by + simp [repLorentzGroup_apply] + +/-- On a component function the Lorentz action is the action on the component space. -/ +@[simp] +lemma repLorentzGroup_ι (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (v : JetComponentSpace V) : + repLorentzGroup repV Λ (SymmetricAlgebra.ι ℂ _ v) = + SymmetricAlgebra.ι ℂ _ (JetComponentSpace.repLorentzGroup repV Λ v) := by + rw [repLorentzGroup_apply, SymmetricAlgebra.map_apply_ι] + +/-- The Lorentz action as an algebra homomorphism: it preserves the symmetric product, so a + Lorentz transformation acts on a Lagrangian term factor by factor. -/ +noncomputable def repLorentzGroupAlgHom (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) : + BosonicAlgebra V →ₐ[ℂ] BosonicAlgebra V where + toFun := repLorentzGroup repV Λ + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repLorentzGroup_apply_one repV Λ + map_mul' := repLorentzGroup_apply_mul repV Λ + commutes' r := by simp [repLorentzGroup_apply] + +/-! + +### A.1. Equivariance of the field and its conjugate + +-/ + +/-- **`ofField` is `SL(2,ℂ)`-equivariant.** The undifferentiated component functions carry + the contragredient of the representation on the target space, and no derivative labels + are generated: `ofField` intertwines `repV.dual` with the action on the bosonic + algebra. -/ +@[simp] +lemma repLorentzGroup_ofField (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ V) : + repLorentzGroup repV Λ (ofField φ) = ofField (repV.dual Λ φ) := by + rw [ofField_apply, repLorentzGroup_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst_tmul, + DerivAlgebraComplex.repLorentzGroup_apply_one] + rfl + · rw [JetComponentSpace.repLorentzGroup_snd] + exact map_zero _ + +/-- **`ofConjField` is `SL(2,ℂ)`-equivariant**, for the conjugate of the representation on + the target space: the conjugate component functions transform by `star` of the spinor + matrix. -/ +@[simp] +lemma repLorentzGroup_ofConjField (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ (ConjModule V)) : + repLorentzGroup repV Λ (ofConjField φ) = ofConjField (repV.conj.dual Λ φ) := by + rw [ofConjField_apply, repLorentzGroup_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst] + exact map_zero _ + · rw [JetComponentSpace.repLorentzGroup_snd] + show (DerivAlgebraComplex.repLorentzGroup Λ 1) ⊗ₜ[ℂ] (repV.conj.dual Λ φ) = _ + rw [DerivAlgebraComplex.repLorentzGroup_apply_one] + +/-! + +## B. Lorentz covariance of the total derivative + +-/ + +set_option maxHeartbeats 4000000 in +/-- **The total derivative on the bosonic algebra is a Lorentz vector.** The four + derivations `∂_μ` transform into each other by the columns of the Lorentz matrix of `Λ`, + exactly as the covector index `μ` should. -/ +lemma repLorentzGroup_jetDeriv (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra V) : + repLorentzGroup repV Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup repV Λ x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => + rw [jetDeriv_algebraMap, map_zero] + refine (Finset.sum_eq_zero fun a _ => ?_).symm + rw [Algebra.algebraMap_eq_smul_one, map_smul, repLorentzGroup_apply_one, map_smul, + jetDeriv_one, smul_zero, smul_zero] + | ι v => + rw [jetDeriv_ι, repLorentzGroup_ι, repLorentzGroup_ι, + JetComponentSpace.repLorentzGroup_jetDeriv, map_sum] + exact Finset.sum_congr rfl fun a _ => by rw [map_smul, jetDeriv_ι] + | mul a b ha hb => + rw [jetDeriv_mul, map_add, repLorentzGroup_apply_mul, repLorentzGroup_apply_mul, ha, hb, + Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib, repLorentzGroup_apply_mul] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [jetDeriv_mul, smul_add, smul_mul_assoc, mul_smul_comm] + | add a b ha hb => + rw [map_add, map_add, map_add, ha, hb, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + +/-- The total derivatives on the bosonic algebra form a Lorentz derivative, giving access + to the boost-weight machinery of `Physlib.Relativity.IsLorentzDeriv`. -/ +instance instIsLorentzDeriv (repV : Representation ℂ SL(2,ℂ) V) : + Lorentz.IsLorentzDeriv (repLorentzGroup repV) (jetDeriv (V := V)) where + rep_deriv := repLorentzGroup_jetDeriv repV _ _ _ + +end BosonicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassDim.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassDim.lean new file mode 100644 index 000000000..ac5c26bf2 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/MassDim.lean @@ -0,0 +1,128 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +/-! +# Mass dimension on the bosonic algebra + +## i. Overview + +The mass dimension of a bosonic matter field is tracked multiplicatively through the +*mass-weight scaling*: the algebra endomorphism multiplying each generator `∂_s φ_α` by +`c ^ (w + 2 |s|)`, where `w` is the mass weight of the field — twice its mass dimension, +kept integral so the same machinery serves the fermions of dimension `3/2`. A monomial of +total mass weight `n` is scaled by `c ^ n`, so the scaling records the mass-weight grading +of the algebra, and its interaction with the total derivative says that a derivative +carries mass weight two. + +## ii. Key results + +- `BosonicAlgebra.massWeightScale` : the mass-weight scaling. +- `BosonicAlgebra.massWeightScale_ofField` : the field carries its own mass weight. +- `BosonicAlgebra.massWeightScale_jetDeriv` : a derivative adds mass weight two. +- `BosonicAlgebra.massWeightScale_iteratedJetDeriv` : `∂_s` adds mass weight `2 |s|`. + +## iii. Table of contents + +- A. The mass-weight scaling +- B. The mass weight of the field and its derivatives + +-/ + +@[expose] public section + +namespace StandardModel + +namespace BosonicAlgebra + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The mass-weight scaling + +-/ + +/-- **The mass-weight scaling on the bosonic algebra** of a field of mass weight `w`: + the algebra endomorphism scaling the generator `∂_s φ_α` by `c ^ (w + 2 |s|)`, the + functorial lift of the scaling on the jet component space. -/ +noncomputable def massWeightScale (w : ℕ) (c : ℂ) : BosonicAlgebra V →ₐ[ℂ] BosonicAlgebra V := + SymmetricAlgebra.map (JetComponentSpace.massWeightScale w c) + +@[simp] +lemma massWeightScale_ι (w : ℕ) (c : ℂ) (x : JetComponentSpace V) : + massWeightScale w c (SymmetricAlgebra.ι ℂ _ x) + = SymmetricAlgebra.ι ℂ _ (JetComponentSpace.massWeightScale w c x) := + SymmetricAlgebra.map_apply_ι _ x + +/-! + +## B. The mass weight of the field and its derivatives + +-/ + +/-- The undifferentiated field carries its own mass weight. -/ +@[simp] +lemma massWeightScale_ofField (w : ℕ) (c : ℂ) (φ : Module.Dual ℂ V) : + massWeightScale w c (ofField φ) = c ^ w • ofField φ := by + rw [ofField_apply, massWeightScale_ι, ← map_smul] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.massWeightScale_fst] + simp only [TensorProduct.map_tmul, AlgHom.toLinearMap_apply, map_one, + LinearMap.id_apply, Prod.smul_fst, TensorProduct.smul_tmul'] + · rw [JetComponentSpace.massWeightScale_snd] + simp + +/-- The undifferentiated conjugate field carries the same mass weight as the field. -/ +@[simp] +lemma massWeightScale_ofConjField (w : ℕ) (c : ℂ) (φ : Module.Dual ℂ (ConjModule V)) : + massWeightScale w c (ofConjField φ) = c ^ w • ofConjField φ := by + rw [ofConjField_apply, massWeightScale_ι, ← map_smul] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.massWeightScale_fst] + simp + · rw [JetComponentSpace.massWeightScale_snd] + simp only [TensorProduct.map_tmul, AlgHom.toLinearMap_apply, map_one, + LinearMap.id_apply, Prod.smul_snd, TensorProduct.smul_tmul'] + +/-- **A total derivative adds mass weight two**: the scaling intertwines the total + derivative up to a factor `c ^ 2`. -/ +lemma massWeightScale_jetDeriv (w : ℕ) (c : ℂ) (μ : Fin 1 ⊕ Fin 3) (x : BosonicAlgebra V) : + massWeightScale w c (jetDeriv μ x) = c ^ 2 • jetDeriv μ (massWeightScale w c x) := by + induction x using SymmetricAlgebra.induction with + | algebraMap r => rw [jetDeriv_algebraMap, map_zero, AlgHom.commutes, jetDeriv_algebraMap, + smul_zero] + | ι v => + rw [jetDeriv_ι, massWeightScale_ι, massWeightScale_ι, jetDeriv_ι, ← map_smul] + exact congrArg (SymmetricAlgebra.ι ℂ _) + (LinearMap.congr_fun (JetComponentSpace.massWeightScale_jetDeriv w c μ) v) + | mul a b ha hb => + simp only [jetDeriv_mul, map_add, map_mul, ha, hb, smul_add, smul_mul_assoc, + mul_smul_comm] + | add a b ha hb => simp only [map_add, ha, hb, smul_add] + +/-- **The iterated derivative `∂_s` adds mass weight `2 |s|`.** -/ +lemma massWeightScale_iteratedJetDeriv (w : ℕ) (c : ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : BosonicAlgebra V) : + massWeightScale w c (iteratedJetDeriv s x) + = c ^ (2 * Multiset.card s) • iteratedJetDeriv s (massWeightScale w c x) := by + induction s using Multiset.induction_on generalizing x with + | empty => simp + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, massWeightScale_jetDeriv, ih, + map_smul, LinearMap.comp_apply, smul_smul, ← pow_add] + congr 2 + rw [Multiset.card_cons] + ring + +end BosonicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Prod.lean b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Prod.lean new file mode 100644 index 000000000..659faa4ac --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/BosonicAlgebra/Prod.lean @@ -0,0 +1,62 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.Basic +/-! +# The bosonic algebra of a direct sum + +## i. Overview + +Two bosonic matter fields, valued in `V` and `W`, are jointly a single matter field valued +in `V × W`; its bosonic algebra is the **tensor product** of the two individual bosonic +algebras. That is the content of `BosonicAlgebra.prodEquiv`: an algebra equivalence + +`BosonicAlgebra (V × W) ≃ₐ[ℂ] BosonicAlgebra V ⊗[ℂ] BosonicAlgebra W`. + +Unlike the fermionic analogue `FermionicAlgebra.prodEquiv`, the *ordinary* tensor product +suffices: bosonic generators of different species commute, so no grading is needed. + +The proof is two steps. First the component space of a direct sum is the direct sum of the +component spaces (`JetComponentSpace.prodEquiv`). Then the symmetric algebra of a direct +sum is the tensor product of the symmetric algebras, which is +`SymmetricAlgebra.prodEquiv`. + +## ii. Key results + +- `BosonicAlgebra.prodEquiv` : the bosonic algebra of a direct sum is the tensor product + of the bosonic algebras. + +## iii. Table of contents + +- A. The tensor product decomposition + +-/ + +@[expose] public section + +open scoped TensorProduct + +namespace StandardModel + +/-! + +## A. The tensor product decomposition + +-/ + +/-- **The bosonic algebra of a direct sum is the tensor product of the bosonic algebras.** + Two bosonic matter fields taken together are one field valued in the direct sum of their + target spaces, and its bosonic algebra is the tensor product of theirs. The ordinary — + rather than the graded — tensor product is correct here: bosonic generators commute + across species just as they do within one. -/ +noncomputable def BosonicAlgebra.prodEquiv (V W : Type) [AddCommGroup V] [Module ℂ V] + [AddCommGroup W] [Module ℂ W] : + BosonicAlgebra (V × W) ≃ₐ[ℂ] BosonicAlgebra V ⊗[ℂ] BosonicAlgebra W := + (SymmetricAlgebra.congr (JetComponentSpace.prodEquiv V W)).trans + SymmetricAlgebra.prodEquiv + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Basic.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Basic.lean new file mode 100644 index 000000000..6b28fdab6 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Basic.lean @@ -0,0 +1,188 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic +/-! +# The fermionic algebra of a matter field + +## i. Overview + +For a matter field valued in a complex vector space `V`, the *fermionic algebra* is the +exterior algebra on the jet component space `JetComponentSpace V`. It is the algebra in +which the `V`-part of a Lagrangian lives: the generators are the component functions +`∂_s ψ_α` and their conjugates `∂_s ψ̄_α`, and the exterior product implements the +anticommutativity of fermionic fields. + +Everything the component space carries lifts to the fermionic algebra by functoriality of +the exterior algebra: the Lorentz action (`FermionicAlgebra.repLorentzGroup`), the jet +gauge action (`FermionicAlgebra.repJetGaugeGroupI`), and the formal total derivative +(`FermionicAlgebra.jetDeriv`), which extends as an even derivation rather than by +functoriality. Those live in the sibling files `LorentzAction`, `GaugeAction` and +`JetDeriv`. + +## ii. Key results + +- `FermionicAlgebra` : the exterior algebra on the jet component space. +- `FermionicAlgebra.adjoin_ι_eq_top` : the algebra is generated by the component functions. +- `FermionicAlgebra.ofField`, `FermionicAlgebra.ofConjField` : the field and its conjugate. +- `FermionicAlgebra.comap` : the inclusion of a species, contravariant in the target space. + +## iii. Table of contents + +- A. The fermionic algebra + - A.1. The generators of the fermionic algebra + - A.2. The field and its conjugate + - A.3. Inclusion of a species + +-/ + +@[expose] public section + +namespace StandardModel + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The fermionic algebra + +-/ + +/-- The fermionic algebra of a `V`-valued matter field: the exterior algebra on the space + of component functions `∂_s ψ_α` and `∂_s ψ̄_α`. The exterior product is the product of + fermionic fields, its anticommutativity the Fermi statistics. -/ +abbrev FermionicAlgebra (V : Type) [AddCommGroup V] [Module ℂ V] : Type := + ExteriorAlgebra ℂ (JetComponentSpace V) + +namespace FermionicAlgebra + +/-! + +### A.1. The generators of the fermionic algebra + +-/ + +/-- **The fermionic algebra is generated by the component functions.** Every element is a + polynomial in the degree-one elements — the symbols `∂_s ψ_α` and `∂_s ψ̄_α` themselves. + This is the algebraic form of "every Lagrangian term is a polynomial in the component + functions". -/ +@[simp] +lemma adjoin_ι_eq_top : + Algebra.adjoin ℂ (Set.range (ExteriorAlgebra.ι ℂ (M := JetComponentSpace V))) = ⊤ := + CliffordAlgebra.adjoin_range_ι + +/-- A component function squares to zero: no fermionic field appears twice. -/ +lemma ι_sq_zero (x : JetComponentSpace V) : + ExteriorAlgebra.ι ℂ x * ExteriorAlgebra.ι ℂ x = (0 : FermionicAlgebra V) := + ExteriorAlgebra.ι_sq_zero x + +/-- Two component functions anticommute. -/ +lemma ι_mul_ι_swap (x y : JetComponentSpace V) : + (ExteriorAlgebra.ι ℂ x * ExteriorAlgebra.ι ℂ y : FermionicAlgebra V) + = - (ExteriorAlgebra.ι ℂ y * ExteriorAlgebra.ι ℂ x) := + eq_neg_of_add_eq_zero_left (ExteriorAlgebra.ι_add_mul_swap (R := ℂ) x y) + +/-! + +### A.2. The field and its conjugate + +The undifferentiated component functions sit inside the fermionic algebra as the two +inclusions below. A component function is a *covector* on the target space: `ofField φ` is +the component of the field `ψ` along `φ`, the element written `ψ_α` when `φ` is the `α`-th +coordinate. The conjugate field is a covector on `ConjModule V`, whose scalar action is +twisted by complex conjugation — that twist is exactly the statement that `ψ̄` transforms +by the conjugate of the representation carried by `ψ`. + +Every other generator of the algebra is an iterated derivative of one of these, which is +the content of `FermionicAlgebra.adjoin_iteratedJetDeriv_eq_top`. + +-/ + +/-- **The component function `ψ_φ` of the matter field** along the covector `φ` on `V`: the + undifferentiated generator, sitting at the empty derivative label in the unconjugated half + of the component space. -/ +noncomputable def ofField : Module.Dual ℂ V →ₗ[ℂ] FermionicAlgebra V := + (ExteriorAlgebra.ι ℂ).comp + ((LinearMap.inl ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V))).comp + (TensorProduct.mk ℂ DerivAlgebraComplex (Module.Dual ℂ V) 1)) + +/-- **The component function `ψ̄_φ` of the conjugate matter field** along the covector `φ` on + `ConjModule V`: the undifferentiated generator in the conjugate half of the component + space. -/ +noncomputable def ofConjField : Module.Dual ℂ (ConjModule V) →ₗ[ℂ] FermionicAlgebra V := + (ExteriorAlgebra.ι ℂ).comp + ((LinearMap.inr ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V))).comp + (TensorProduct.mk ℂ DerivAlgebraComplex (Module.Dual ℂ (ConjModule V)) 1)) + +lemma ofField_apply (φ : Module.Dual ℂ V) : + ofField φ = ExteriorAlgebra.ι ℂ + (((1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ, 0) : JetComponentSpace V) := rfl + +lemma ofConjField_apply (φ : Module.Dual ℂ (ConjModule V)) : + ofConjField φ = ExteriorAlgebra.ι ℂ + ((0, (1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ) : JetComponentSpace V) := rfl + +/-! + +### A.3. Inclusion of a species + +A field valued in `V` that is one *species* among several — i.e. `V` is a summand of a +larger target space `U` — has its fermionic algebra sitting inside the fermionic algebra of +`U`. The inclusion is induced by the *projection* `U →ₗ[ℂ] V`, because component functions +are covectors on the target and therefore transpose. `comap` is that induced map, and it is +functorial and compatible with everything the algebra carries. + +-/ + +variable {W : Type} [AddCommGroup W] [Module ℂ W] + +/-- **The fermionic algebra is contravariant in the target space.** A linear map + `f : V →ₗ[ℂ] W` induces an algebra homomorphism `FermionicAlgebra W →ₐ[ℂ] FermionicAlgebra V` + by pulling back component functions. Applied to a *projection* out of a multi-species target + space, this is the inclusion of one species' algebra into the whole. -/ +noncomputable def comap (f : V →ₗ[ℂ] W) : FermionicAlgebra W →ₐ[ℂ] FermionicAlgebra V := + ExteriorAlgebra.map (JetComponentSpace.comap f) + +@[simp] +lemma comap_ι (f : V →ₗ[ℂ] W) (x : JetComponentSpace W) : + comap f (ExteriorAlgebra.ι ℂ x) + = ExteriorAlgebra.ι ℂ (JetComponentSpace.comap f x) := by + rw [comap, ExteriorAlgebra.map_apply_ι] + +@[simp] +lemma comap_id : comap (LinearMap.id : V →ₗ[ℂ] V) = AlgHom.id ℂ (FermionicAlgebra V) := by + rw [comap, JetComponentSpace.comap_id, ExteriorAlgebra.map_id] + +/-- Functoriality: the order reverses, as it must for a contravariant construction. -/ +lemma comap_comp {U : Type} [AddCommGroup U] [Module ℂ U] (f : V →ₗ[ℂ] W) (g : W →ₗ[ℂ] U) : + comap (g.comp f) = (comap f).comp (comap g) := by + rw [comap, comap, comap, JetComponentSpace.comap_comp, ← ExteriorAlgebra.map_comp_map] + +/-- The inclusion sends a component function of the species to the corresponding component + function of the whole. -/ +@[simp] +lemma comap_ofField (f : V →ₗ[ℂ] W) (φ : Module.Dual ℂ W) : + comap f (ofField φ) = ofField (φ ∘ₗ f) := by + rw [ofField_apply, comap_ι, ofField_apply] + congr 1 + +/-- The inclusion sends a conjugate component function of the species to the corresponding + conjugate component function of the whole. -/ +@[simp] +lemma comap_ofConjField (f : V →ₗ[ℂ] W) (φ : Module.Dual ℂ (ConjModule W)) : + comap f (ofConjField φ) = ofConjField (φ ∘ₗ ConjModule.map f) := by + rw [ofConjField_apply, comap_ι, ofConjField_apply] + congr 1 + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/GaugeAction.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/GaugeAction.lean new file mode 100644 index 000000000..4db30dbf3 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/GaugeAction.lean @@ -0,0 +1,241 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Basic +/-! +# The gauge action on the fermionic algebra + +## i. Overview + +Given a fibrewise action of the jet gauge group on the jets `JetRing ⊗[ℂ] V` of a matter +field, the jet gauge group acts on the fermionic algebra by the exterior-algebra functor +applied to the induced action on the jet component space. On a component function `∂_s ψ_α` +the action is the all-orders Leibniz rule: each splitting of the derivative multiset +contributes a Taylor coefficient of the gauge jet against a lower component function. + +Restricting along `JetGaugeGroupI.ofConstant` gives the action of the constant — that is, +global — gauge transformations, which is diagonal in the derivative label. + +## ii. Key results + +- `FermionicAlgebra.repJetGaugeGroupI` : the jet gauge action on the fermionic algebra. +- `FermionicAlgebra.repJetGaugeGroupIAlgHom` : the action as an algebra homomorphism. +- `FermionicAlgebra.repJetGaugeGroupI_ofField` : `ofField` is gauge equivariant, for the + value of the gauge transformation at the base point. +- `FermionicAlgebra.repGaugeGroupI` : the action of the constant gauge transformations. + +## iii. Table of contents + +- A. The action of the jet gauge group + - A.1. Equivariance of the field and its conjugate +- B. Constant gauge transformations + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] [Module.Free ℂ V] [Module.Finite ℂ V] + +/-! + +## A. The action of the jet gauge group + +-/ + +/-- **The jet gauge action on the fermionic algebra** of a `V`-valued matter field, induced + from a fibrewise action `rep` on the jets of the field: the exterior-algebra functor + applied to the gauge action on the jet component space. The hypothesis `hlin` is the + statement that a gauge transformation acts on the *values* of the field, over the + identity on spacetime. -/ +noncomputable def repJetGaugeGroupI + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ JetGaugeGroupI (FermionicAlgebra V) where + toFun U := + (ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI rep hlin U)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' U W := by + simp only [map_mul, Module.End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repJetGaugeGroupI_apply + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x : FermionicAlgebra V) : + repJetGaugeGroupI rep hlin U x = + ExteriorAlgebra.map (JetComponentSpace.repJetGaugeGroupI rep hlin U) x := rfl + +@[simp] +lemma repJetGaugeGroupI_apply_one + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) : + repJetGaugeGroupI rep hlin U (1 : FermionicAlgebra V) = 1 := by + simp [repJetGaugeGroupI_apply] + +lemma repJetGaugeGroupI_apply_mul + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x y : FermionicAlgebra V) : + repJetGaugeGroupI rep hlin U (x * y) = + repJetGaugeGroupI rep hlin U x * repJetGaugeGroupI rep hlin U y := by + simp [repJetGaugeGroupI_apply] + +/-- On a component function the jet gauge action is the action on the component space. -/ +@[simp] +lemma repJetGaugeGroupI_ι + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (v : JetComponentSpace V) : + repJetGaugeGroupI rep hlin U (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.repJetGaugeGroupI rep hlin U v) := by + rw [repJetGaugeGroupI_apply, ExteriorAlgebra.map_apply_ι] + +/-- The jet gauge action as an algebra homomorphism: a gauge transformation acts on a + Lagrangian term factor by factor. -/ +noncomputable def repJetGaugeGroupIAlgHom + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) : FermionicAlgebra V →ₐ[ℂ] FermionicAlgebra V where + toFun := repJetGaugeGroupI rep hlin U + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repJetGaugeGroupI_apply_one rep hlin U + map_mul' := repJetGaugeGroupI_apply_mul rep hlin U + commutes' r := by simp [repJetGaugeGroupI_apply] + +/-! + +### A.1. Equivariance of the field and its conjugate + +Unlike a derivative generator `∂_s ψ_φ`, which mixes with lower generators through the +Taylor coefficients of the gauge jet, the undifferentiated generator `ψ_φ` transforms by +the *value* of the gauge transformation at the base point alone. So `ofField` and +`ofConjField` are equivariant on the nose, for the contragredient of that value. + +-/ + +/-- **`ofField` is gauge equivariant.** The undifferentiated component functions transform + by the contragredient of the value of the gauge transformation at the base point; no + derivative of the gauge jet contributes. -/ +lemma repJetGaugeGroupI_ofField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (φ : Module.Dual ℂ V) : + repJetGaugeGroupI rep hlin U (ofField φ) = + ofField (Module.Dual.transpose (jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant) φ) := by + rw [ofField_apply, repJetGaugeGroupI_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · exact repDual_one_tmul rep hlin U φ + · rw [JetComponentSpace.repJetGaugeGroupI_snd] + exact map_zero _ + +/-- **`ofConjField` is gauge equivariant**, for the conjugate action `repConj rep` on the + jets of the conjugate field — which is the physicists' `ψ̄ ↦ ψ̄ U†`. -/ +lemma repJetGaugeGroupI_ofConjField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)) : + repJetGaugeGroupI rep hlin U (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (repConj rep U⁻¹).comp jetOfConstant) φ) := by + rw [ofConjField_apply, repJetGaugeGroupI_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repJetGaugeGroupI_fst] + exact map_zero _ + · exact repDual_one_tmul (repConj rep) (repConj_smul_comm hlin) U φ + +/-! + +## B. Constant gauge transformations + +-/ + +/-- The action of the constant — that is, global — gauge transformations on the fermionic + algebra, obtained by including a gauge transformation as a constant gauge jet. -/ +noncomputable def repGaugeGroupI + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ GaugeGroupI (FermionicAlgebra V) := + (repJetGaugeGroupI rep hlin).comp JetGaugeGroupI.ofConstant + +lemma repGaugeGroupI_apply + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (x : FermionicAlgebra V) : + repGaugeGroupI rep hlin g x = + repJetGaugeGroupI rep hlin (JetGaugeGroupI.ofConstant g) x := rfl + +@[simp] +lemma repGaugeGroupI_apply_one + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) : + repGaugeGroupI rep hlin g (1 : FermionicAlgebra V) = 1 := + repJetGaugeGroupI_apply_one rep hlin _ + +lemma repGaugeGroupI_apply_mul + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (x y : FermionicAlgebra V) : + repGaugeGroupI rep hlin g (x * y) = + repGaugeGroupI rep hlin g x * repGaugeGroupI rep hlin g y := + repJetGaugeGroupI_apply_mul rep hlin _ x y + +/-- A constant gauge transformation acts on the undifferentiated field by the + contragredient of its value — which for a constant jet is the transformation itself. -/ +lemma repGaugeGroupI_ofField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (φ : Module.Dual ℂ V) : + repGaugeGroupI rep hlin g (ofField φ) = + ofField (Module.Dual.transpose + (jetEval ∘ₗ (rep (JetGaugeGroupI.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (JetGaugeGroupI.ofConstant g)⁻¹ = JetGaugeGroupI.ofConstant g⁻¹ := + (map_inv JetGaugeGroupI.ofConstant g).symm + rw [repGaugeGroupI_apply, repJetGaugeGroupI_ofField, h] + +/-- A constant gauge transformation acts on the undifferentiated conjugate field by the + conjugate contragredient of its value. -/ +lemma repGaugeGroupI_ofConjField + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (g : GaugeGroupI) (φ : Module.Dual ℂ (ConjModule V)) : + repGaugeGroupI rep hlin g (ofConjField φ) = + ofConjField (Module.Dual.transpose + (jetEval ∘ₗ (repConj rep (JetGaugeGroupI.ofConstant g⁻¹)).comp jetOfConstant) φ) := by + have h : (JetGaugeGroupI.ofConstant g)⁻¹ = JetGaugeGroupI.ofConstant g⁻¹ := + (map_inv JetGaugeGroupI.ofConstant g).symm + rw [repGaugeGroupI_apply, repJetGaugeGroupI_ofConjField, h] + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/JetDeriv.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/JetDeriv.lean new file mode 100644 index 000000000..b93f93377 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/JetDeriv.lean @@ -0,0 +1,411 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Basic +public import Physlib.Relativity.IsLorentzDeriv +public import Mathlib.Algebra.TrivSqZeroExt.Basic +/-! +# The formal total derivative on the fermionic algebra + +## i. Overview + +The formal total spacetime derivative extends from the component functions to the whole +fermionic algebra as an even derivation. It is constructed by lifting the generator map +`ι x ↦ (ι x, ι (∂_μ x))` to an algebra homomorphism into the trivial square-zero extension +of the fermionic algebra; the square-zero condition holds because degree-one elements of an +exterior algebra anticommute. + +The four directional derivatives commute, so they iterate along a *multiset* of directions +through `Lorentz.iteratedD`. On a component function the iterate is multiplication by the +derivative symbol `∂_s` in the `DerivAlgebraComplex` factor, and on a product it obeys the +all-orders Leibniz rule over the antidiagonal of the multiset. + +## ii. Key results + +- `FermionicAlgebra.jetDeriv` : the formal total spacetime derivative. +- `FermionicAlgebra.jetDeriv_mul` : the Leibniz rule. +- `FermionicAlgebra.jetDeriv_comm` : total derivatives commute. +- `FermionicAlgebra.iteratedJetDeriv` : the iterated derivative along a multiset. +- `FermionicAlgebra.iteratedJetDeriv_mul` : the all-orders Leibniz rule. +- `FermionicAlgebra.adjoin_iteratedJetDeriv_eq_top` : the algebra is generated by the field, + its conjugate, and their derivatives. +- `FermionicAlgebra.comap_jetDeriv` : the inclusion of a species commutes with the + derivative. + +## iii. Table of contents + +- A. The formal total derivative on the fermionic algebra +- B. The iterated total derivative +- C. Generation by the field and its derivatives +- D. Compatibility with the inclusion of a species + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The formal total derivative on the fermionic algebra + +The formal total spacetime derivative extends from the component functions to the whole +fermionic algebra as an even derivation: `∂_μ (x y) = (∂_μ x) y + x (∂_μ y)`, with no +Koszul signs. + +-/ + +/-- The generator map of the total derivative into the trivial square-zero extension of the + fermionic algebra: `ι x ↦ (ι x, ι (∂_μ x))`. -/ +noncomputable def jetDerivGen (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace V →ₗ[ℂ] TrivSqZeroExt (FermionicAlgebra V) (FermionicAlgebra V) where + toFun x := (ExteriorAlgebra.ι ℂ x, + ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x)) + map_add' x y := by + simp only [map_add] + rfl + map_smul' c x := by + simp only [map_smul, RingHom.id_apply] + rfl + +@[simp] +lemma jetDerivGen_fst (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + (jetDerivGen μ x).fst = ExteriorAlgebra.ι ℂ x := rfl + +@[simp] +lemma jetDerivGen_snd (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + (jetDerivGen μ x).snd = ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x) := rfl + +/-- The generator map squares to zero: degree-one elements of the exterior algebra + anticommute. -/ +lemma jetDerivGen_mul_self (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + jetDerivGen μ x * jetDerivGen μ x = 0 := by + refine TrivSqZeroExt.ext ?_ ?_ + · rw [TrivSqZeroExt.fst_mul, jetDerivGen_fst, ExteriorAlgebra.ι_sq_zero, + TrivSqZeroExt.fst_zero] + · rw [TrivSqZeroExt.snd_mul, jetDerivGen_fst, jetDerivGen_snd, TrivSqZeroExt.snd_zero, + smul_eq_mul, op_smul_eq_mul] + exact ExteriorAlgebra.ι_add_mul_swap x (JetComponentSpace.jetDeriv μ x) + +/-- The lift of the total derivative to the trivial square-zero extension of the fermionic + algebra: the algebra homomorphism `x ↦ (x, ∂_μ x)`. -/ +noncomputable def jetDerivHom (μ : Fin 1 ⊕ Fin 3) : + FermionicAlgebra V →ₐ[ℂ] TrivSqZeroExt (FermionicAlgebra V) (FermionicAlgebra V) := + ExteriorAlgebra.lift ℂ ⟨jetDerivGen μ, jetDerivGen_mul_self μ⟩ + +@[simp] +lemma jetDerivHom_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + jetDerivHom μ (ExteriorAlgebra.ι ℂ x) = jetDerivGen μ x := by + rw [jetDerivHom, ExteriorAlgebra.lift_ι_apply] + +/-- The first component of the square-zero lift is the identity. -/ +@[simp] +lemma jetDerivHom_fst (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra V) : + (jetDerivHom μ x).fst = x := by + have h : (TrivSqZeroExt.fstHom ℂ (FermionicAlgebra V) (FermionicAlgebra V)).comp + (jetDerivHom μ) = AlgHom.id ℂ (FermionicAlgebra V) := by + refine ExteriorAlgebra.hom_ext (LinearMap.ext fun v => ?_) + simp + exact DFunLike.congr_fun h x + +/-- The formal total spacetime derivative on the fermionic algebra of a `V`-valued matter + field in the direction `μ`: the even derivation extending the shift + `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the component functions. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : + FermionicAlgebra V →ₗ[ℂ] FermionicAlgebra V where + toFun x := (jetDerivHom μ x).snd + map_add' x y := congrArg TrivSqZeroExt.snd (map_add (jetDerivHom μ) x y) + map_smul' c x := congrArg TrivSqZeroExt.snd (map_smul (jetDerivHom μ) c x) + +lemma jetDeriv_apply (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra V) : + jetDeriv μ x = (jetDerivHom μ x).snd := rfl + +/-- On a component function the total derivative is the shift of the derivative label. -/ +@[simp] +lemma jetDeriv_ι (μ : Fin 1 ⊕ Fin 3) (x : JetComponentSpace V) : + jetDeriv μ (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.jetDeriv μ x) := by + rw [jetDeriv_apply, jetDerivHom_ι, jetDerivGen_snd] + +@[simp] +lemma jetDeriv_one (μ : Fin 1 ⊕ Fin 3) : jetDeriv (V := V) μ (1 : FermionicAlgebra V) = 0 := + congrArg TrivSqZeroExt.snd (map_one (jetDerivHom (V := V) μ)) + +@[simp] +lemma jetDeriv_algebraMap (μ : Fin 1 ⊕ Fin 3) (r : ℂ) : + jetDeriv (V := V) μ (algebraMap ℂ (FermionicAlgebra V) r) = 0 := by + rw [Algebra.algebraMap_eq_smul_one, map_smul, jetDeriv_one, smul_zero] + +/-- The total derivative is an even derivation: the Leibniz rule holds on the fermionic + algebra with no Koszul signs. -/ +lemma jetDeriv_mul (μ : Fin 1 ⊕ Fin 3) (x y : FermionicAlgebra V) : + jetDeriv μ (x * y) = jetDeriv μ x * y + x * jetDeriv μ y := by + have h : jetDeriv μ (x * y) = + (jetDerivHom μ x).fst * jetDeriv μ y + jetDeriv μ x * (jetDerivHom μ y).fst := + congrArg TrivSqZeroExt.snd (map_mul (jetDerivHom μ) x y) + rw [jetDerivHom_fst, jetDerivHom_fst] at h + exact h.trans (add_comm _ _) + +/-- **Mixed partials agree.** The derivative labels live in a *symmetric* algebra, so the + total derivatives in different directions commute. -/ +lemma jetDeriv_comm_apply (μ ν : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra V) : + jetDeriv μ (jetDeriv ν x) = jetDeriv ν (jetDeriv μ x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => simp + | ι v => + rw [jetDeriv_ι, jetDeriv_ι, jetDeriv_ι, jetDeriv_ι] + exact congrArg (ExteriorAlgebra.ι ℂ) + (DFunLike.congr_fun (JetComponentSpace.jetDeriv_comm (V := V) μ ν) v) + | mul x y hx hy => + simp only [jetDeriv_mul, map_add, hx, hy] + abel + | add x y hx hy => simp only [map_add, hx, hy] + +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv (V := V) μ).comp (jetDeriv ν) = (jetDeriv (V := V) ν).comp (jetDeriv μ) := + LinearMap.ext fun x => jetDeriv_comm_apply μ ν x + +/-! + +## B. The iterated total derivative + +-/ + +/-- The iterated total derivative `∂_s = ∂_{ν₁} ⋯ ∂_{νₙ}` along a multiset `s` of + directions. It is well defined on a multiset — i.e. independent of the order in which the + directions are listed — because the directional derivatives commute. -/ +noncomputable def iteratedJetDeriv (s : Multiset (Fin 1 ⊕ Fin 3)) : + FermionicAlgebra V →ₗ[ℂ] FermionicAlgebra V := + Lorentz.iteratedD jetDeriv jetDeriv_comm s + +@[simp] +lemma iteratedJetDeriv_zero : + iteratedJetDeriv (0 : Multiset (Fin 1 ⊕ Fin 3)) + = LinearMap.id (R := ℂ) (M := FermionicAlgebra V) := + Lorentz.iteratedD_zero jetDeriv jetDeriv_comm + +lemma iteratedJetDeriv_cons (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (μ ::ₘ s) = (jetDeriv μ).comp (iteratedJetDeriv s) := + Lorentz.iteratedD_cons jetDeriv jetDeriv_comm μ s + +/-- The companion of `iteratedJetDeriv_cons`, peeling the extra derivative on the inside. -/ +lemma iteratedJetDeriv_cons' (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (μ ::ₘ s) = (iteratedJetDeriv s).comp (jetDeriv μ) := + Lorentz.iteratedD_cons' jetDeriv jetDeriv_comm μ s + +@[simp] +lemma iteratedJetDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + iteratedJetDeriv (V := V) {μ} = jetDeriv μ := + Lorentz.iteratedD_singleton jetDeriv jetDeriv_comm μ + +/-- The iterated derivative is additive in the multiset of directions: differentiating + along `s + t` is differentiating along `t` and then along `s`. -/ +lemma iteratedJetDeriv_add (s t : Multiset (Fin 1 ⊕ Fin 3)) : + iteratedJetDeriv (V := V) (s + t) + = (iteratedJetDeriv s).comp (iteratedJetDeriv t) := + Lorentz.iteratedD_add jetDeriv jetDeriv_comm s t + +/-- **The all-orders Leibniz rule.** The iterated derivative of a product distributes over + the antidiagonal of the multiset of directions: each way of splitting the derivatives + between the two factors contributes one term. -/ +lemma iteratedJetDeriv_mul (s : Multiset (Fin 1 ⊕ Fin 3)) (x y : FermionicAlgebra V) : + iteratedJetDeriv s (x * y) = + (s.antidiagonal.map fun p => + iteratedJetDeriv p.1 x * iteratedJetDeriv p.2 y).sum := + Lorentz.iteratedD_mul jetDeriv jetDeriv_comm jetDeriv_mul s x y + +/-- A nonempty iterated derivative kills the constants. -/ +lemma iteratedJetDeriv_one_of_ne_zero {s : Multiset (Fin 1 ⊕ Fin 3)} (hs : s ≠ 0) : + iteratedJetDeriv (V := V) s (1 : FermionicAlgebra V) = 0 := by + obtain ⟨μ, hμ⟩ := Multiset.exists_mem_of_ne_zero hs + obtain ⟨t, rfl⟩ := Multiset.exists_cons_of_mem hμ + rw [iteratedJetDeriv_cons', LinearMap.comp_apply, jetDeriv_one, map_zero] + +/-- **On a component function the iterated derivative is the derivative symbol `∂_s`.** + Both halves of the component space — the field and its conjugate — are multiplied by the + degree-`|s|` element `∂_s` of `DerivAlgebraComplex` in their derivative-label factor, + with the target index untouched. -/ +lemma iteratedJetDeriv_ι (s : Multiset (Fin 1 ⊕ Fin 3)) (x : JetComponentSpace V) : + iteratedJetDeriv s (ExteriorAlgebra.ι ℂ x) = + ExteriorAlgebra.ι ℂ + (TensorProduct.map (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis s)) + LinearMap.id x.1, + TensorProduct.map (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis s)) + LinearMap.id x.2) := by + have hmul : ∀ t u : Multiset (Fin 1 ⊕ Fin 3), + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis t)).comp + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis u)) + = LinearMap.mulRight ℂ (DerivAlgebraComplex.basis (u + t)) := fun t u => + LinearMap.ext fun a => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, mul_assoc, + DerivAlgebraComplex.basis_mul] + have hone : LinearMap.mulRight ℂ (1 : DerivAlgebraComplex) = LinearMap.id := + LinearMap.ext fun a => mul_one a + have hnil : DerivAlgebraComplex.basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 := + DerivAlgebraComplex.basis_nil + induction s using Multiset.induction_on with + | empty => + rw [iteratedJetDeriv_zero, LinearMap.id_apply, hnil, hone] + simp only [TensorProduct.map_id, LinearMap.id_apply] + | cons μ s ih => + have hs : s + ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ s := by + rw [add_comm, Multiset.singleton_add] + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, ih, jetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.jetDeriv_fst, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, hmul, hs] + · rw [JetComponentSpace.jetDeriv_snd, ← LinearMap.comp_apply, ← TensorProduct.map_comp, + LinearMap.id_comp, hmul, hs] + +/-! + +## C. Generation by the field and its derivatives + +-/ + +/-- The iterated derivative of the field is the generator carrying the derivative symbol + `∂_s`: applying `∂_s` to `ψ_φ` writes the label `s` into the derivative factor. -/ +@[simp] +lemma iteratedJetDeriv_ofField (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + iteratedJetDeriv s (ofField φ) = + ExteriorAlgebra.ι ℂ ((DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ, 0) : JetComponentSpace V) := by + rw [ofField_apply, iteratedJetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, one_mul, LinearMap.id_apply] + · rw [map_zero] + +/-- The iterated derivative of the conjugate field is the conjugate generator carrying the + derivative symbol `∂_s`. -/ +@[simp] +lemma iteratedJetDeriv_ofConjField (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ (ConjModule V)) : + iteratedJetDeriv s (ofConjField φ) = + ExteriorAlgebra.ι ℂ ((0, DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) : JetComponentSpace V) := by + rw [ofConjField_apply, iteratedJetDeriv_ι] + congr 1 + refine Prod.ext ?_ ?_ + · rw [map_zero] + · rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, one_mul, LinearMap.id_apply] + +/-- **The fermionic algebra is generated by the field, its conjugate, and their + derivatives.** As a `ℂ`-algebra, `FermionicAlgebra V` is the algebra adjoined by the + iterated total derivatives `∂_s ψ_φ` and `∂_s ψ̄_φ` of the undifferentiated component + functions. Physically: every Lagrangian term for a `V`-valued matter field is a + polynomial in the field, its conjugate, and their spacetime derivatives — nothing else is + available to write down. + + This sharpens `adjoin_ι_eq_top`, which only says the algebra is generated by the + component functions; here the component functions are themselves produced from the two + inclusions `ofField` and `ofConjField` by differentiating. -/ +theorem adjoin_iteratedJetDeriv_eq_top : + Algebra.adjoin ℂ + (⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule V) => + iteratedJetDeriv s (ofConjField φ))) + = (⊤ : Subalgebra ℂ (FermionicAlgebra V)) := by + set S : Set (FermionicAlgebra V) := + ⋃ s : Multiset (Fin 1 ⊕ Fin 3), + Set.range (fun φ : Module.Dual ℂ V => iteratedJetDeriv s (ofField φ)) ∪ + Set.range (fun φ : Module.Dual ℂ (ConjModule V) => + iteratedJetDeriv s (ofConjField φ)) with hS + /- The two half-inclusions of the component space into the fermionic algebra. -/ + let gField : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V →ₗ[ℂ] FermionicAlgebra V := + (ExteriorAlgebra.ι ℂ).comp (LinearMap.inl ℂ _ _) + let gConj : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V) →ₗ[ℂ] + FermionicAlgebra V := + (ExteriorAlgebra.ι ℂ).comp (LinearMap.inr ℂ _ _) + /- On a derivative monomial each half-inclusion is one of the adjoined generators. -/ + have hbasisField : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + gField (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gField (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) = iteratedJetDeriv s (ofField φ) := + (iteratedJetDeriv_ofField s φ).symm + rw [h, hS] + exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨s, Or.inl ⟨φ, rfl⟩⟩) + have hbasisConj : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ (ConjModule V)), + gConj (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) ∈ Algebra.adjoin ℂ S := by + intro s φ + have h : gConj (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) + = iteratedJetDeriv s (ofConjField φ) := (iteratedJetDeriv_ofConjField s φ).symm + rw [h, hS] + exact Algebra.subset_adjoin (Set.mem_iUnion.mpr ⟨s, Or.inr ⟨φ, rfl⟩⟩) + /- The derivative monomials span, so each half-inclusion lands in the adjoined algebra. -/ + have hhalf : ∀ {W : Type} [AddCommGroup W] [Module ℂ W] + (g : DerivAlgebraComplex ⊗[ℂ] W →ₗ[ℂ] FermionicAlgebra V), + (∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (w : W), + g (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] w) ∈ Algebra.adjoin ℂ S) → + ∀ y, g y ∈ Algebra.adjoin ℂ S := by + intro W _ _ g hg y + induction y using TensorProduct.induction_on with + | zero => rw [map_zero]; exact zero_mem _ + | add y z hy hz => rw [map_add]; exact add_mem hy hz + | tmul a w => + have ha : a ∈ Submodule.span ℂ (Set.range DerivAlgebraComplex.basis) := by + rw [DerivAlgebraComplex.basis.span_eq]; trivial + induction ha using Submodule.span_induction with + | mem b hb => obtain ⟨s, rfl⟩ := hb; exact hg s w + | zero => rw [TensorProduct.zero_tmul, map_zero]; exact zero_mem _ + | add b c _ _ hb hc => rw [TensorProduct.add_tmul, map_add]; exact add_mem hb hc + | smul c b _ hb => + rw [← TensorProduct.smul_tmul', map_smul] + exact Subalgebra.smul_mem _ hb c + /- Every component function is a sum of its two halves. -/ + refine top_le_iff.mp ?_ + rw [← adjoin_ι_eq_top (V := V)] + refine Algebra.adjoin_le ?_ + rintro _ ⟨x, rfl⟩ + have hx : x = LinearMap.inl ℂ _ _ x.1 + LinearMap.inr ℂ _ _ x.2 := by + refine Prod.ext ?_ ?_ <;> simp + rw [hx, map_add] + exact add_mem (hhalf gField hbasisField x.1) (hhalf gConj hbasisConj x.2) + +/-! + +## D. Compatibility with the inclusion of a species + +-/ + +variable {W : Type} [AddCommGroup W] [Module ℂ W] + +/-- **The inclusion of a species is a map of differential algebras.** Pulling back along a + map of target spaces commutes with the total derivative: the two act on different labels + of a component function. -/ +lemma comap_jetDeriv (f : V →ₗ[ℂ] W) (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra W) : + comap f (jetDeriv μ x) = jetDeriv μ (comap f x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => + rw [jetDeriv_algebraMap, map_zero, AlgHom.commutes, jetDeriv_algebraMap] + | ι v => + rw [jetDeriv_ι, comap_ι, comap_ι, jetDeriv_ι] + exact congrArg (ExteriorAlgebra.ι ℂ) + (DFunLike.congr_fun (JetComponentSpace.comap_jetDeriv f μ) v) + | mul a b ha hb => simp only [jetDeriv_mul, map_add, map_mul, ha, hb] + | add a b ha hb => simp only [map_add, ha, hb] + +/-- The inclusion of a species commutes with the iterated total derivative. -/ +lemma comap_iteratedJetDeriv (f : V →ₗ[ℂ] W) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : FermionicAlgebra W) : + comap f (iteratedJetDeriv s x) = iteratedJetDeriv s (comap f x) := by + induction s using Multiset.induction_on generalizing x with + | empty => rw [iteratedJetDeriv_zero, LinearMap.id_apply, iteratedJetDeriv_zero, + LinearMap.id_apply] + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, comap_jetDeriv, ih, + iteratedJetDeriv_cons, LinearMap.comp_apply] + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/LorentzAction.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/LorentzAction.lean new file mode 100644 index 000000000..de334ec09 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/LorentzAction.lean @@ -0,0 +1,185 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +/-! +# The Lorentz action on the fermionic algebra + +## i. Overview + +Given a representation of `SL(2,ℂ)` on the target space `V` of a matter field, the Lorentz +group acts on the fermionic algebra by the exterior-algebra functor applied to its action +on the jet component space. On a component function `∂_s ψ_α` the derivative labels +transform by the Lorentz matrix and the target index contragrediently by `V`. + +The formal total derivative is a Lorentz vector for this action, which is exactly the +content of the class `Lorentz.IsLorentzDeriv`; the instance is registered here, so all the +boost-weight machinery of `Physlib.Relativity.IsLorentzDeriv` applies to the fermionic +algebra of any matter field. + +## ii. Key results + +- `FermionicAlgebra.repLorentzGroup` : the Lorentz action on the fermionic algebra. +- `FermionicAlgebra.repLorentzGroupAlgHom` : the action as an algebra homomorphism. +- `FermionicAlgebra.repLorentzGroup_ofField` : `ofField` is `SL(2,ℂ)`-equivariant. +- `FermionicAlgebra.repLorentzGroup_jetDeriv` : the total derivative is a Lorentz vector. +- `FermionicAlgebra.instIsLorentzDeriv` : the resulting `Lorentz.IsLorentzDeriv` instance. + +## iii. Table of contents + +- A. The action of the Lorentz group + - A.1. Equivariance of the field and its conjugate +- B. Lorentz covariance of the total derivative + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open Matrix MatrixGroups TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The action of the Lorentz group + +-/ + +/-- **The Lorentz action on the fermionic algebra** of a `V`-valued matter field, induced + from a representation `repV` of `SL(2,ℂ)` on `V`: the exterior-algebra functor applied to + the Lorentz action on the jet component space. -/ +noncomputable def repLorentzGroup (repV : Representation ℂ SL(2,ℂ) V) : + Representation ℂ SL(2,ℂ) (FermionicAlgebra V) where + toFun Λ := (ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup repV Λ)).toLinearMap + map_one' := by + simp only [map_one, Module.End.one_eq_id, ExteriorAlgebra.map_id, + AlgHom.toLinearMap_id] + map_mul' Λ₁ Λ₂ := by + simp only [map_mul, Module.End.mul_eq_comp, ← ExteriorAlgebra.map_comp_map, + AlgHom.comp_toLinearMap] + +lemma repLorentzGroup_apply (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (x : FermionicAlgebra V) : + repLorentzGroup repV Λ x = + ExteriorAlgebra.map (JetComponentSpace.repLorentzGroup repV Λ) x := rfl + +@[simp] +lemma repLorentzGroup_apply_one (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) : + repLorentzGroup repV Λ (1 : FermionicAlgebra V) = 1 := by + simp [repLorentzGroup_apply] + +lemma repLorentzGroup_apply_mul (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (x y : FermionicAlgebra V) : + repLorentzGroup repV Λ (x * y) + = repLorentzGroup repV Λ x * repLorentzGroup repV Λ y := by + simp [repLorentzGroup_apply] + +/-- On a component function the Lorentz action is the action on the component space. -/ +@[simp] +lemma repLorentzGroup_ι (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (v : JetComponentSpace V) : + repLorentzGroup repV Λ (ExteriorAlgebra.ι ℂ v) = + ExteriorAlgebra.ι ℂ (JetComponentSpace.repLorentzGroup repV Λ v) := by + rw [repLorentzGroup_apply, ExteriorAlgebra.map_apply_ι] + +/-- The Lorentz action as an algebra homomorphism: it preserves the exterior product, so a + Lorentz transformation acts on a Lagrangian term factor by factor. -/ +noncomputable def repLorentzGroupAlgHom (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) : + FermionicAlgebra V →ₐ[ℂ] FermionicAlgebra V where + toFun := repLorentzGroup repV Λ + map_add' := LinearMap.map_add _ + map_zero' := LinearMap.map_zero _ + map_one' := repLorentzGroup_apply_one repV Λ + map_mul' := repLorentzGroup_apply_mul repV Λ + commutes' r := by simp [repLorentzGroup_apply] + +/-! + +### A.1. Equivariance of the field and its conjugate + +-/ + +/-- **`ofField` is `SL(2,ℂ)`-equivariant.** The undifferentiated component functions carry + the contragredient of the representation on the target space, and no derivative labels + are generated: `ofField` intertwines `repV.dual` with the action on the fermionic + algebra. -/ +@[simp] +lemma repLorentzGroup_ofField (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ V) : + repLorentzGroup repV Λ (ofField φ) = ofField (repV.dual Λ φ) := by + rw [ofField_apply, repLorentzGroup_ι, ofField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst_tmul, + DerivAlgebraComplex.repLorentzGroup_apply_one] + rfl + · rw [JetComponentSpace.repLorentzGroup_snd] + exact map_zero _ + +/-- **`ofConjField` is `SL(2,ℂ)`-equivariant**, for the conjugate of the representation on + the target space: the conjugate component functions transform by `star` of the spinor + matrix. -/ +@[simp] +lemma repLorentzGroup_ofConjField (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (φ : Module.Dual ℂ (ConjModule V)) : + repLorentzGroup repV Λ (ofConjField φ) = ofConjField (repV.conj.dual Λ φ) := by + rw [ofConjField_apply, repLorentzGroup_ι, ofConjField_apply] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.repLorentzGroup_fst] + exact map_zero _ + · rw [JetComponentSpace.repLorentzGroup_snd] + show (DerivAlgebraComplex.repLorentzGroup Λ 1) ⊗ₜ[ℂ] (repV.conj.dual Λ φ) = _ + rw [DerivAlgebraComplex.repLorentzGroup_apply_one] + +/-! + +## B. Lorentz covariance of the total derivative + +-/ + +set_option maxHeartbeats 4000000 in +/-- **The total derivative on the fermionic algebra is a Lorentz vector.** The four + derivations `∂_μ` transform into each other by the columns of the Lorentz matrix of `Λ`, + exactly as the covector index `μ` should. -/ +lemma repLorentzGroup_jetDeriv (repV : Representation ℂ SL(2,ℂ) V) (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) (x : FermionicAlgebra V) : + repLorentzGroup repV Λ (jetDeriv μ x) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + jetDeriv a (repLorentzGroup repV Λ x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => + rw [jetDeriv_algebraMap, map_zero] + refine (Finset.sum_eq_zero fun a _ => ?_).symm + rw [Algebra.algebraMap_eq_smul_one, map_smul, repLorentzGroup_apply_one, map_smul, + jetDeriv_one, smul_zero, smul_zero] + | ι v => + rw [jetDeriv_ι, repLorentzGroup_ι, repLorentzGroup_ι, + JetComponentSpace.repLorentzGroup_jetDeriv, map_sum] + exact Finset.sum_congr rfl fun a _ => by rw [map_smul, jetDeriv_ι] + | mul a b ha hb => + rw [jetDeriv_mul, map_add, repLorentzGroup_apply_mul, repLorentzGroup_apply_mul, ha, hb, + Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib, repLorentzGroup_apply_mul] + refine Finset.sum_congr rfl fun c _ => ?_ + rw [jetDeriv_mul, smul_add, smul_mul_assoc, mul_smul_comm] + | add a b ha hb => + rw [map_add, map_add, map_add, ha, hb, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + +/-- The total derivatives on the fermionic algebra form a Lorentz derivative, giving access + to the boost-weight machinery of `Physlib.Relativity.IsLorentzDeriv`. -/ +instance instIsLorentzDeriv (repV : Representation ℂ SL(2,ℂ) V) : + Lorentz.IsLorentzDeriv (repLorentzGroup repV) (jetDeriv (V := V)) where + rep_deriv := repLorentzGroup_jetDeriv repV _ _ _ + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassDim.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassDim.lean new file mode 100644 index 000000000..640e37d73 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/MassDim.lean @@ -0,0 +1,131 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.JetDeriv +/-! +# Mass dimension on the fermionic algebra + +## i. Overview + +The mass dimension of a fermionic matter field is tracked multiplicatively through the +*mass-weight scaling*: the algebra endomorphism multiplying each generator `∂_s ψ_α` by +`c ^ (w + 2 |s|)`, where `w` is the mass weight of the field — twice its mass dimension, +kept integral because a fermion has mass dimension `3/2` and hence mass weight `3`. A +monomial of total mass weight `n` is scaled by `c ^ n`, so the scaling records the +mass-weight grading of the algebra, and its interaction with the total derivative says +that a derivative carries mass weight two. This mirrors +`Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim`. + +## ii. Key results + +- `FermionicAlgebra.massWeightScale` : the mass-weight scaling. +- `FermionicAlgebra.massWeightScale_ofField` : the field carries its own mass weight. +- `FermionicAlgebra.massWeightScale_jetDeriv` : a derivative adds mass weight two. +- `FermionicAlgebra.massWeightScale_iteratedJetDeriv` : `∂_s` adds mass weight `2 |s|`. + +## iii. Table of contents + +- A. The mass-weight scaling +- B. The mass weight of the field and its derivatives + +-/ + +@[expose] public section + +namespace StandardModel + +namespace FermionicAlgebra + +open TensorProduct + +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## A. The mass-weight scaling + +-/ + +/-- **The mass-weight scaling on the fermionic algebra** of a field of mass weight `w`: + the algebra endomorphism scaling the generator `∂_s ψ_α` by `c ^ (w + 2 |s|)`, the + functorial lift of the scaling on the jet component space. -/ +noncomputable def massWeightScale (w : ℕ) (c : ℂ) : + FermionicAlgebra V →ₐ[ℂ] FermionicAlgebra V := + ExteriorAlgebra.map (JetComponentSpace.massWeightScale w c) + +@[simp] +lemma massWeightScale_ι (w : ℕ) (c : ℂ) (x : JetComponentSpace V) : + massWeightScale w c (ExteriorAlgebra.ι ℂ x) + = ExteriorAlgebra.ι ℂ (JetComponentSpace.massWeightScale w c x) := by + rw [massWeightScale, ExteriorAlgebra.map_apply_ι] + +/-! + +## B. The mass weight of the field and its derivatives + +-/ + +/-- The undifferentiated field carries its own mass weight. -/ +@[simp] +lemma massWeightScale_ofField (w : ℕ) (c : ℂ) (φ : Module.Dual ℂ V) : + massWeightScale w c (ofField φ) = c ^ w • ofField φ := by + rw [ofField_apply, massWeightScale_ι, ← map_smul] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.massWeightScale_fst] + simp only [TensorProduct.map_tmul, AlgHom.toLinearMap_apply, map_one, + LinearMap.id_apply, Prod.smul_fst, TensorProduct.smul_tmul'] + · rw [JetComponentSpace.massWeightScale_snd] + simp + +/-- The undifferentiated conjugate field carries the same mass weight as the field. -/ +@[simp] +lemma massWeightScale_ofConjField (w : ℕ) (c : ℂ) (φ : Module.Dual ℂ (ConjModule V)) : + massWeightScale w c (ofConjField φ) = c ^ w • ofConjField φ := by + rw [ofConjField_apply, massWeightScale_ι, ← map_smul] + congr 1 + refine Prod.ext ?_ ?_ + · rw [JetComponentSpace.massWeightScale_fst] + simp + · rw [JetComponentSpace.massWeightScale_snd] + simp only [TensorProduct.map_tmul, AlgHom.toLinearMap_apply, map_one, + LinearMap.id_apply, Prod.smul_snd, TensorProduct.smul_tmul'] + +/-- **A total derivative adds mass weight two**: the scaling intertwines the total + derivative up to a factor `c ^ 2`. -/ +lemma massWeightScale_jetDeriv (w : ℕ) (c : ℂ) (μ : Fin 1 ⊕ Fin 3) + (x : FermionicAlgebra V) : + massWeightScale w c (jetDeriv μ x) = c ^ 2 • jetDeriv μ (massWeightScale w c x) := by + induction x using ExteriorAlgebra.induction with + | algebraMap r => rw [jetDeriv_algebraMap, map_zero, AlgHom.commutes, jetDeriv_algebraMap, + smul_zero] + | ι v => + rw [jetDeriv_ι, massWeightScale_ι, massWeightScale_ι, jetDeriv_ι, ← map_smul] + exact congrArg (ExteriorAlgebra.ι ℂ) + (LinearMap.congr_fun (JetComponentSpace.massWeightScale_jetDeriv w c μ) v) + | mul a b ha hb => + simp only [jetDeriv_mul, map_add, map_mul, ha, hb, smul_add, smul_mul_assoc, + mul_smul_comm] + | add a b ha hb => simp only [map_add, ha, hb, smul_add] + +/-- **The iterated derivative `∂_s` adds mass weight `2 |s|`.** -/ +lemma massWeightScale_iteratedJetDeriv (w : ℕ) (c : ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) + (x : FermionicAlgebra V) : + massWeightScale w c (iteratedJetDeriv s x) + = c ^ (2 * Multiset.card s) • iteratedJetDeriv s (massWeightScale w c x) := by + induction s using Multiset.induction_on generalizing x with + | empty => simp + | cons μ s ih => + rw [iteratedJetDeriv_cons, LinearMap.comp_apply, massWeightScale_jetDeriv, ih, + map_smul, LinearMap.comp_apply, smul_smul, ← pow_add] + congr 2 + rw [Multiset.card_cons] + ring + +end FermionicAlgebra + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Prod.lean b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Prod.lean new file mode 100644 index 000000000..a71cf57d5 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/FermionicAlgebra/Prod.lean @@ -0,0 +1,106 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.Matter.FermionicAlgebra.Basic +public import Mathlib.LinearAlgebra.CliffordAlgebra.Prod +public import Mathlib.LinearAlgebra.TensorProduct.Prod +/-! +# The fermionic algebra of a direct sum + +## i. Overview + +Two matter fields, valued in `V` and `W`, are jointly a single matter field valued in +`V × W`; its fermionic algebra is the **exterior product** of the two individual fermionic +algebras. That is the content of `FermionicAlgebra.prodEquiv`: an algebra equivalence + +`FermionicAlgebra (V × W) ≃ₐ[ℂ] (evenOdd V ᵍ⊗[ℂ] evenOdd W)` + +onto the graded tensor product of the two algebras with respect to their Fermi-parity +gradings. The graded — as opposed to ordinary — tensor product is what makes generators of +*different* species anticommute, as fermions must. + +The proof is two steps. First the component space of a direct sum is the direct sum of the +component spaces (`JetComponentSpace.prodEquiv`) — duals and conjugates both split. Then the +exterior algebra of a direct sum is the graded tensor product of the exterior algebras, +which is `CliffordAlgebra.prodEquiv` specialized to the zero quadratic form. + +## ii. Key results + +- `FermionicAlgebra.evenOdd` : the Fermi-parity grading. +- `FermionicAlgebra.prodEquiv` : the fermionic algebra of a direct sum is the exterior + product of the fermionic algebras. + +## iii. Table of contents + +- A. The component space of a direct sum +- B. The Fermi-parity grading +- C. The exterior product decomposition + +-/ + +@[expose] public section + +open scoped TensorProduct + +/-- Transport of an exterior algebra along a linear equivalence of the underlying module. -/ +noncomputable def ExteriorAlgebra.congr {R A B : Type*} [CommRing R] [AddCommGroup A] + [Module R A] [AddCommGroup B] [Module R B] (e : A ≃ₗ[R] B) : + ExteriorAlgebra R A ≃ₐ[R] ExteriorAlgebra R B := + CliffordAlgebra.equivOfIsometry ⟨e, fun _ => rfl⟩ + +namespace StandardModel + +variable {V W : Type} [AddCommGroup V] [Module ℂ V] [AddCommGroup W] [Module ℂ W] + +/-! + +## A. The component space of a direct sum + +The splitting `JetComponentSpace.prodEquiv` of the component space of a direct sum lives +with the component space itself, in `Physlib.Particles.StandardModel.Matter.JetComponentSpace.Basic`. + +-/ + +/-! + +## B. The Fermi-parity grading + +-/ + +/-- **The Fermi-parity grading** of the fermionic algebra: the `ZMod 2` grading of the + exterior algebra by the number of component functions in a monomial. An even element + commutes with everything; two odd elements anticommute. -/ +abbrev FermionicAlgebra.evenOdd (V : Type) [AddCommGroup V] [Module ℂ V] : + ZMod 2 → Submodule ℂ (FermionicAlgebra V) := + CliffordAlgebra.evenOdd (0 : QuadraticForm ℂ (JetComponentSpace V)) + +/-! + +## C. The exterior product decomposition + +-/ + +/-- **The fermionic algebra of a direct sum is the exterior product of the fermionic + algebras.** Two matter fields taken together are one field valued in the direct sum of + their target spaces, and its fermionic algebra is the graded tensor product of theirs. + + The tensor product must be the *graded* one `ᵍ⊗`: an ordinary `⊗[ℂ]` would make a + generator of the first field commute with a generator of the second, whereas fermionic + generators anticommute across species just as they do within one. -/ +noncomputable def FermionicAlgebra.prodEquiv (V W : Type) [AddCommGroup V] [Module ℂ V] + [AddCommGroup W] [Module ℂ W] : + FermionicAlgebra (V × W) ≃ₐ[ℂ] + (FermionicAlgebra.evenOdd V ᵍ⊗[ℂ] FermionicAlgebra.evenOdd W) := + (ExteriorAlgebra.congr (JetComponentSpace.prodEquiv V W)).trans <| + (CliffordAlgebra.equivOfIsometry + (Q₁ := (0 : QuadraticForm ℂ (JetComponentSpace V × JetComponentSpace W))) + (Q₂ := (0 : QuadraticForm ℂ (JetComponentSpace V)).prod + (0 : QuadraticForm ℂ (JetComponentSpace W))) + ⟨LinearEquiv.refl ℂ _, fun _ => by simp⟩).trans + (CliffordAlgebra.prodEquiv _ _) + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/JetComponentSpace/Basic.lean b/Physlib/Particles/StandardModel/Matter/JetComponentSpace/Basic.lean new file mode 100644 index 000000000..6fc02e221 --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/JetComponentSpace/Basic.lean @@ -0,0 +1,851 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Particles.StandardModel.Matter.JetComponentSpace.CovariantDeriv +public import Mathlib.LinearAlgebra.Contraction +public import Mathlib.LinearAlgebra.TensorProduct.Prod +/-! +# The jet component space of a matter field + +## i. Overview + +For a matter field valued in a complex vector space `V`, the *jet component space* is the +span of the derivative symbols `∂_s ψ_α` and their conjugates `∂_s ψ̄_α`: the local +coordinate functions on the space of jets of the field. This file defines that space and +constructs the action of the jet gauge group on it, induced from an action on the jets +`JetRing ⊗[ℂ] V` of the field itself. + +The construction needs two hypotheses on the jet action `rep`: + +* `hlin` — that `rep` is *fibrewise*, `rep U (χ • z) = χ • rep U z`, the statement that a + gauge transformation acts on the values of the field over the identity on spacetime. + This is what makes the induced action local (a finite Leibniz convolution) and what + makes `rep` determined by its restriction to constant jets. +* finite dimensionality of `V`, which makes that restriction a *matrix of power series*, + an element of `JetRing ⊗ End V`. + +## ii. Key results + +- `JetComponentSpace` : the space of component functions. +- `jetCoeff` : the coefficient of a fibrewise action, in `JetRing ⊗ End V`. +- `coeff_mul_of_smul_comm` : the coefficient is multiplicative. +- `symbolAction`, `symbolAction_mul` : its action on symbols, an anti-homomorphism. +- `repDual` : the induced action on the unconjugated symbols. +- `repConj`, `repConj_smul_comm` : the action on the jets of the conjugate field. +- `JetComponentSpace.repJetGaugeGroupI` : the action on the full component space. +- `JetComponentSpace.repLorentzGroup` : the Lorentz action on the component space. +- `JetComponentSpace.jetDeriv` : the shift `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the label. +- `JetComponentSpace.jetDeriv_comm` : the shifts in different directions commute. +- `JetComponentSpace.repLorentzGroup_jetDeriv` : the shift is a Lorentz vector. +- `JetComponentSpace.comap` : functoriality, contravariant in the target space. + +-/ + +@[expose] public section + +namespace StandardModel + +open Matrix MatrixGroups TensorProduct + +variable {V : Type _} [AddCommGroup V] [Module ℂ V] + + +/-- The space of component functions of a `V`-valued matter field: the span of the +symbols `∂_s ψ_α` and their conjugates `∂_s ψ̄_α`. The first factor holds the +unconjugated symbols, the second the conjugate ones; in each, `DerivAlgebraComplex` +carries the derivative label `s` and the dual factor the target component `α`. -/ +abbrev JetComponentSpace (V : Type _) [AddCommGroup V] [Module ℂ V] := + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) × + (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V)) + +/-- **A fibrewise action is determined by its values on constant jets.** If the gauge +action commutes with multiplication by scalar jets — the statement that it acts on the +values of the field, over the identity on spacetime — then its value on a general jet +`f ⊗ₜ v` is the constant-jet value `rep U (1 ⊗ₜ v)` scaled by `f`. -/ +lemma rep_tmul_of_smul_comm + {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (f : JetRing) (v : V) : + rep U (f ⊗ₜ[ℂ] v) = f • rep U (jetOfConstant v) := by + rw [← hlin U f (jetOfConstant v), jetOfConstant_apply, + show f • ((1 : JetRing) ⊗ₜ[ℂ] v) = f ⊗ₜ[ℂ] v from by + rw [TensorProduct.smul_tmul', smul_eq_mul, mul_one]] + +/-- **The canonical evaluation is a right module map.** Writing `ev` for the canonical +`JetRing ⊗ End V → (V →ₗ JetRing ⊗ V)`, `g ⊗ T ↦ (v ↦ g ⊗ₜ T v)`, multiplying on the +right by `b ⊗ T` applies `T` to the argument and scales the value by `b`. -/ +lemma lift_mul_tmul (x : JetRing ⊗[ℂ] Module.End ℂ V) + (b : JetRing) (T : Module.End ℂ V) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (x * (b ⊗ₜ[ℂ] T)) v + = b • TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) x (T v) := by + induction x using TensorProduct.induction_on with + | zero => + have h0 : (0 : JetRing ⊗[ℂ] Module.End ℂ V) * (b ⊗ₜ[ℂ] T) = 0 := by exact zero_mul (b ⊗ₜ[ℂ] T) + rw [h0] + simp + | tmul a S => + rw [Algebra.TensorProduct.tmul_mul_tmul] + show (a * b) ⊗ₜ[ℂ] (S * T) v = b • (a ⊗ₜ[ℂ] S (T v)) + rw [Module.End.mul_apply, TensorProduct.smul_tmul', smul_eq_mul, mul_comm b a] + | add p q hp hq => + have hd : (p + q) * (b ⊗ₜ[ℂ] T) = p * (b ⊗ₜ[ℂ] T) + q * (b ⊗ₜ[ℂ] T) := by + exact Distrib.right_distrib p q (b ⊗ₜ[ℂ] T) + rw [hd, map_add, LinearMap.add_apply, hp, hq, map_add, LinearMap.add_apply, + smul_add] + +/-- **A fibrewise action is the `JetRing`-linear extension of its coefficient.** If the +element `x` of `JetRing ⊗ End V` records `rep U` on constant jets, then `rep U` agrees +with left multiplication by `x` on every coefficient `y`. -/ +lemma rep_lift_of_smul_comm + {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x : JetRing ⊗[ℂ] Module.End ℂ V) + (hx : ∀ v : V, TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) x v = rep U (jetOfConstant v)) + (y : JetRing ⊗[ℂ] Module.End ℂ V) (v : V) : + rep U (TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) y v) + = TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (x * y) v := by + induction y using TensorProduct.induction_on with + | zero => + have h0 : x * (0 : JetRing ⊗[ℂ] Module.End ℂ V) = 0 := by exact mul_zero x + rw [h0] + simp + | tmul b T => + rw [lift_mul_tmul x b T v, + show TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (b ⊗ₜ[ℂ] T) v = b ⊗ₜ[ℂ] T v from rfl, + rep_tmul_of_smul_comm hlin U b (T v), hx (T v)] + | add p q hp hq => + have hd : x * (p + q) = x * p + x * q := by exact Distrib.left_distrib x p q + rw [hd, map_add, LinearMap.add_apply, map_add, map_add, LinearMap.add_apply, + hp, hq] + +/-- **The coefficient of a fibrewise action is multiplicative.** Recording `rep` on +constant jets as a family `c` in `JetRing ⊗ End V`, group multiplication becomes +multiplication in that algebra. This is the identity that makes the induced action on +the symbols a representation, and it needs no basis. -/ +lemma coeff_mul_of_smul_comm + {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (c : JetGaugeGroupI → JetRing ⊗[ℂ] Module.End ℂ V) + (hc : ∀ (U : JetGaugeGroupI) (v : V), + TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (c U) v = rep U (jetOfConstant v)) + (U W : JetGaugeGroupI) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (c U * c W) v + = rep (U * W) (jetOfConstant v) := by + rw [← rep_lift_of_smul_comm hlin U (c U) (hc U) (c W) v, hc W v, map_mul, + Module.End.mul_apply] + +/-- **The symbol action of a coefficient is an anti-homomorphism.** Let `Θ` send a +coefficient `g ⊗ T` in `JetRing ⊗ End V` to the endomorphism `jetRingAction g ⊗ Tᵀ` of +the symbol space `DerivAlgebraComplex ⊗ Dual V`. Then `Θ` reverses products: the jet-ring +factor is multiplicative (`jetRingAction_mul`, and `JetRing` is commutative) while the +target factor is contravariant (`Module.Dual.transpose_comp`). Composed with `U ↦ U⁻¹` +this is exactly what makes the induced action a representation, with no induction over +the antidiagonal. -/ +lemma symbolAction_mul + (Θ : (JetRing ⊗[ℂ] Module.End ℂ V) →ₗ[ℂ] + Module.End ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V)) + (hΘ : ∀ (g : JetRing) (T : Module.End ℂ V), + Θ (g ⊗ₜ[ℂ] T) = TensorProduct.map (DerivAlgebraComplex.jetRingAction g) + (Module.Dual.transpose T)) + (x y : JetRing ⊗[ℂ] Module.End ℂ V) : + Θ (x * y) = Θ y ∘ₗ Θ x := by + induction x using TensorProduct.induction_on with + | zero => + have h0 : (0 : JetRing ⊗[ℂ] Module.End ℂ V) * y = 0 := by exact zero_mul y + rw [h0, map_zero] + simp + | tmul a S => + induction y using TensorProduct.induction_on with + | zero => + have h0 : (a ⊗ₜ[ℂ] S) * (0 : JetRing ⊗[ℂ] Module.End ℂ V) = 0 := by + exact mul_zero (a ⊗ₜ[ℂ] S) + rw [h0, map_zero] + simp + | tmul b T => + rw [Algebra.TensorProduct.tmul_mul_tmul, hΘ, hΘ, hΘ, + ← TensorProduct.map_comp, ← DerivAlgebraComplex.jetRingAction_mul, + ← Module.Dual.transpose_comp, Module.End.mul_eq_comp, mul_comm a b] + | add p q hp hq => + have hd : (a ⊗ₜ[ℂ] S) * (p + q) = (a ⊗ₜ[ℂ] S) * p + (a ⊗ₜ[ℂ] S) * q := by + exact Distrib.left_distrib (a ⊗ₜ[ℂ] S) p q + rw [hd, map_add, map_add, LinearMap.add_comp, hp, hq] + | add p q hp hq => + have hd : (p + q) * y = p * y + q * y := by exact Distrib.right_distrib p q y + rw [hd, map_add, map_add, LinearMap.comp_add, hp, hq] + +/-- **The coefficient of a linear map, canonically.** For finite-dimensional `V` the +canonical `JetRing ⊗ End V → (V →ₗ JetRing ⊗ V)` is inverted by reassociating the +contraction `Dual V ⊗ (JetRing ⊗ V) ≃ JetRing ⊗ (Dual V ⊗ V) ≃ JetRing ⊗ End V`. This is +the finite-rank input, obtained from `dualTensorHomEquiv` rather than from a basis. -/ +lemma lift_congr_leftComm [Module.Free ℂ V] [Module.Finite ℂ V] + (G : Module.Dual ℂ V ⊗[ℂ] (JetRing ⊗[ℂ] V)) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) + ((TensorProduct.congr (LinearEquiv.refl ℂ JetRing) (dualTensorHomEquiv ℂ V V)) + (TensorProduct.leftComm ℂ (Module.Dual ℂ V) JetRing V G)) v + = dualTensorHom ℂ V (JetRing ⊗[ℂ] V) G v := by + induction G using TensorProduct.induction_on with + | zero => simp + | tmul phi z => + induction z using TensorProduct.induction_on with + | zero => simp + | tmul g w => + rw [TensorProduct.leftComm_tmul, TensorProduct.congr_tmul, + LinearEquiv.refl_apply] + show g ⊗ₜ[ℂ] (dualTensorHomEquiv ℂ V V (phi ⊗ₜ[ℂ] w)) v = _ + rw [show dualTensorHomEquiv ℂ V V (phi ⊗ₜ[ℂ] w) + = dualTensorHom ℂ V V (phi ⊗ₜ[ℂ] w) from rfl, + dualTensorHom_apply, dualTensorHom_apply, TensorProduct.tmul_smul] + | add z₁ z₂ h₁ h₂ => + rw [TensorProduct.tmul_add, map_add, map_add, map_add, LinearMap.add_apply, + map_add, LinearMap.add_apply, h₁, h₂] + | add G₁ G₂ h₁ h₂ => + rw [map_add, map_add, map_add, LinearMap.add_apply, map_add, + LinearMap.add_apply, h₁, h₂] + +/-- **The conjugate jet action.** Given a gauge action on the jets of a `V`-valued field, +this is the induced action on the jets of the *conjugate* field. + +It is `Representation.conj rep` — the same underlying maps, read on `ConjModule` — carried +across the identification + + `ConjModule (JetRing ⊗[ℂ] V) ≃ₗ[ℂ] JetRing ⊗[ℂ] ConjModule V` + +which is `ConjModule.tensorEquiv` (conjugation is monoidal) followed by +`JetRing.starConjEquiv` on the jet-ring factor (the real structure of the jet ring). On +pure tensors the composite is `f ⊗ₜ v ↦ star f ⊗ₜ v`, so `repConj` carries the conjugate +gauge matrix — the physicists' `ψ̄ ↦ ψ̄ U†`. + +Being a representation is free: `LinearEquiv.conjRingEquiv` is a ring equivalence of +endomorphism rings, hence multiplicative. -/ +noncomputable def repConj (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) : + Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] ConjModule V) where + toFun U := LinearEquiv.conjRingEquiv + ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (rep.conj U) + map_one' := by rw [map_one, map_one] + map_mul' U W := by rw [map_mul, map_mul] + + +/-- On pure tensors the conjugate jet action conjugates the jet factor: it is `rep` +evaluated at `star f ⊗ₜ v`, read back through the same identification. -/ +lemma repConj_apply_tmul (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (U : JetGaugeGroupI) (f : JetRing) (v : V) : + repConj rep U (f ⊗ₜ[ℂ] conjEquiv (k := ℂ) (M := V) v) + = ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) + (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (rep U (star f ⊗ₜ[ℂ] v))) := rfl + +/-- **The identification conjugates the jet-ring action.** Carrying a `V`-valued jet over +to the conjugate side turns multiplication by `star χ` into multiplication by `χ`: the +`star` on the jet-ring factor is exactly what absorbs the conjugation. -/ +lemma tensorEquiv_congr_conjEquiv_smul (χ : JetRing) (y : JetRing ⊗[ℂ] V) : + ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (star χ • y)) + = χ • ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) y) := by + induction y using TensorProduct.induction_on with + | zero => simp + | tmul g w => + rw [TensorProduct.smul_tmul', smul_eq_mul] + simp only [LinearEquiv.trans_apply, ConjModule.tensorEquiv_symm_conjEquiv_tmul, + TensorProduct.congr_tmul, LinearEquiv.refl_apply, JetRing.starConjEquiv_apply, + LinearEquiv.symm_apply_apply, TensorProduct.smul_tmul', smul_eq_mul] + rw [star_mul', star_star, mul_comm] + | add a b ha hb => + rw [smul_add, map_add, map_add, ha, hb, map_add, map_add, smul_add] + +/-- **The conjugate jet action is fibrewise-linear whenever the original is.** This is +what lets the coefficient machinery of `coeff_mul_of_smul_comm` be instantiated at +`ConjModule V`, giving the conjugate half of the symbol action. -/ +lemma repConj_smul_comm + {rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)} + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] ConjModule V) : + repConj rep U (χ • z) = χ • repConj rep U z := by + have key : ∀ w : JetRing ⊗[ℂ] V, + repConj rep U (((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)) + = ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) (rep U w)) := by + intro w + show ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) ((rep.conj U) ((((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V))))).symm + (((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) w)))) = _ + rw [LinearEquiv.symm_apply_apply, Representation.conj_apply, + LinearEquiv.symm_apply_apply] + obtain ⟨y, rfl⟩ : ∃ y : JetRing ⊗[ℂ] V, + z = ((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V)))) (conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V) y) := + ⟨(conjEquiv (k := ℂ) (M := JetRing ⊗[ℂ] V)).symm ((((ConjModule.tensorEquiv (k := ℂ) (M := JetRing) (N := V)).symm.trans + (TensorProduct.congr JetRing.starConjEquiv (LinearEquiv.refl ℂ (ConjModule V))))).symm z), by simp⟩ + rw [← tensorEquiv_congr_conjEquiv_smul, key, key, hlin, + tensorEquiv_congr_conjEquiv_smul] + +/-- **The coefficient is determined by its action on constants.** For finite-dimensional +`V` the canonical evaluation `JetRing ⊗ End V → (V →ₗ JetRing ⊗ V)` is injective. -/ +lemma lift_injective [Module.Free ℂ V] [Module.Finite ℂ V] + {x y : JetRing ⊗[ℂ] Module.End ℂ V} + (h : ∀ v : V, TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) x v = TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) y v) : x = y := by + obtain ⟨G, rfl⟩ := ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) JetRing V).trans + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) (dualTensorHomEquiv ℂ V V))).surjective x + obtain ⟨G', rfl⟩ := ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) JetRing V).trans + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) (dualTensorHomEquiv ℂ V V))).surjective y + refine congrArg _ ((dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)).injective + (LinearMap.ext fun v => ?_)) + rw [show (dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)) G + = dualTensorHom ℂ V (JetRing ⊗[ℂ] V) G from rfl, + show (dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)) G' + = dualTensorHom ℂ V (JetRing ⊗[ℂ] V) G' from rfl, + ← lift_congr_leftComm, ← lift_congr_leftComm] + exact h v + +/-- **The coefficient of a fibrewise gauge action.** For finite-dimensional `V`, the +restriction of `rep U` to constant jets is an element of `JetRing ⊗ End V` — a matrix of +power series, obtained canonically from `dualTensorHomEquiv` rather than from a basis. -/ +noncomputable def jetCoeff [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) (U : JetGaugeGroupI) : + JetRing ⊗[ℂ] Module.End ℂ V := + ((TensorProduct.leftComm ℂ (Module.Dual ℂ V) JetRing V).trans + (TensorProduct.congr (LinearEquiv.refl ℂ JetRing) (dualTensorHomEquiv ℂ V V))) + ((dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)).symm ((rep U).comp jetOfConstant)) + +/-- The coefficient reproduces `rep U` on constant jets. -/ +lemma jetCoeff_spec [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) (U : JetGaugeGroupI) (v : V) : + TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (jetCoeff rep U) v = rep U (jetOfConstant v) := by + rw [jetCoeff, LinearEquiv.trans_apply, lift_congr_leftComm, + show dualTensorHom ℂ V (JetRing ⊗[ℂ] V) + ((dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)).symm ((rep U).comp jetOfConstant)) + = (rep U).comp jetOfConstant from + (dualTensorHomEquiv ℂ V (JetRing ⊗[ℂ] V)).apply_symm_apply _] + rfl + +/-- **The action of a coefficient on the symbols.** A coefficient `g ⊗ T` acts by +`jetRingAction g` on the derivative label — the Leibniz convolution redistributing +derivatives between the gauge transformation and the field — and by the transpose `Tᵀ` on +the target index. -/ +noncomputable def symbolAction : + (JetRing ⊗[ℂ] Module.End ℂ V) →ₗ[ℂ] + Module.End ℂ (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) := + TensorProduct.lift + { toFun := fun g => + { toFun := fun T => TensorProduct.map (DerivAlgebraComplex.jetRingAction g) + (Module.Dual.transpose T) + map_add' := fun T₁ T₂ => by rw [map_add, TensorProduct.map_add_right] + map_smul' := fun c T => by + rw [map_smul, TensorProduct.map_smul_right, RingHom.id_apply] } + map_add' := fun g₁ g₂ => by + refine LinearMap.ext fun T => ?_ + show TensorProduct.map (DerivAlgebraComplex.jetRingAction (g₁ + g₂)) _ = _ + rw [DerivAlgebraComplex.jetRingAction_add, TensorProduct.map_add_left] + rfl + map_smul' := fun c g => by + refine LinearMap.ext fun T => ?_ + show TensorProduct.map (DerivAlgebraComplex.jetRingAction (c • g)) _ = _ + rw [show DerivAlgebraComplex.jetRingAction (c • g) + = c • DerivAlgebraComplex.jetRingAction g from by + rw [Algebra.smul_def, MvPowerSeries.algebraMap_apply, + DerivAlgebraComplex.jetRingAction_mul, DerivAlgebraComplex.jetRingAction_C, + LinearMap.smul_comp, LinearMap.id_comp, Algebra.algebraMap_self_apply], + TensorProduct.map_smul_left] + rfl } + +@[simp] +lemma symbolAction_tmul (g : JetRing) (T : Module.End ℂ V) : + symbolAction (g ⊗ₜ[ℂ] T) + = TensorProduct.map (DerivAlgebraComplex.jetRingAction g) (Module.Dual.transpose T) := + rfl + +/-- **A coefficient acts on the undifferentiated symbol through its value at the base +point.** On `1 ⊗ φ` — the symbol `ψ_φ` carrying no derivatives — only the constant term of +the power-series coefficient survives, so the result is again undifferentiated and the +target index is acted on by the transpose of the base-point value. -/ +lemma symbolAction_one_tmul (c : JetRing ⊗[ℂ] Module.End ℂ V) (φ : Module.Dual ℂ V) : + symbolAction c ((1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ) + = (1 : DerivAlgebraComplex) ⊗ₜ[ℂ] + Module.Dual.transpose (jetEval ∘ₗ TensorProduct.lift + ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) c) φ := by + induction c using TensorProduct.induction_on with + | zero => simp + | add c₁ c₂ h₁ h₂ => + rw [map_add, LinearMap.add_apply, h₁, h₂, map_add, LinearMap.comp_add, map_add, + LinearMap.add_apply, TensorProduct.tmul_add] + | tmul g T => + rw [symbolAction_tmul, TensorProduct.map_tmul, + DerivAlgebraComplex.jetRingAction_apply_one, TensorProduct.smul_tmul] + congr 1 + refine LinearMap.ext fun v => ?_ + simp [Module.Dual.transpose] + +/-- **The gauge action on the symbols.** Given a fibrewise gauge action on the jets of a +`V`-valued field, this is the induced (contragredient) action on the derivative symbols +`∂_s ψ_α`, which span `DerivAlgebraComplex ⊗ Module.Dual ℂ V`. + +Multiplicativity is bookkeeping: `coeff_mul_of_smul_comm` makes the coefficient +multiplicative, `symbolAction_mul` makes its action an anti-homomorphism, and the inverse +flips that back. -/ +noncomputable def repDual [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ JetGaugeGroupI (DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) where + toFun U := symbolAction (jetCoeff rep U⁻¹) + map_one' := by + have h1 : jetCoeff rep (1 : JetGaugeGroupI)⁻¹ = 1 := by + refine lift_injective fun v => ?_ + rw [jetCoeff_spec rep] + show rep (1 : JetGaugeGroupI)⁻¹ ((1 : JetRing) ⊗ₜ[ℂ] v) = (1 : JetRing) ⊗ₜ[ℂ] v + rw [inv_one, map_one] + rfl + rw [h1, Algebra.TensorProduct.one_def, symbolAction_tmul, + DerivAlgebraComplex.jetRingAction_one, + show Module.Dual.transpose (1 : Module.End ℂ V) = LinearMap.id from rfl, + TensorProduct.map_id] + rfl + map_mul' U W := by + have hmul : jetCoeff rep (U * W)⁻¹ = jetCoeff rep W⁻¹ * jetCoeff rep U⁻¹ := by + refine lift_injective fun v => ?_ + rw [jetCoeff_spec, + coeff_mul_of_smul_comm hlin (fun A => jetCoeff rep A) (jetCoeff_spec rep) W⁻¹ U⁻¹ v, + _root_.mul_inv_rev] + rw [hmul, symbolAction_mul symbolAction (fun g T => rfl)] + rfl + +/-- **The undifferentiated symbol transforms by the value of the gauge transformation at +the base point.** No derivative of the gauge jet contributes: the symbol `ψ_φ` is acted on +by the contragredient of `rep U⁻¹` restricted to constant jets and evaluated at the base +point. -/ +lemma repDual_one_tmul [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (φ : Module.Dual ℂ V) : + repDual rep hlin U ((1 : DerivAlgebraComplex) ⊗ₜ[ℂ] φ) + = (1 : DerivAlgebraComplex) ⊗ₜ[ℂ] + Module.Dual.transpose (jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant) φ := by + have h : jetEval ∘ₗ TensorProduct.lift ((LinearMap.llcomp ℂ V V (JetRing ⊗[ℂ] V)).comp + (TensorProduct.mk ℂ JetRing V)) (jetCoeff rep U⁻¹) + = jetEval ∘ₗ (rep U⁻¹).comp jetOfConstant := + LinearMap.ext fun v => congrArg jetEval (jetCoeff_spec rep U⁻¹ v) + rw [show repDual rep hlin U = symbolAction (jetCoeff rep U⁻¹) from rfl, + symbolAction_one_tmul, h] + + +/-- **The gauge action on the jet component space.** Given a fibrewise gauge action on the +jets of a `V`-valued field, this is the induced action on the full space of component +functions — the symbols `∂_s ψ_α` together with their conjugates `∂_s ψ̄_α`. + +The unconjugated half is `repDual rep`, the contragredient action on the symbols. The +conjugate half is the *same* construction applied to `repConj rep`, the action on the jets +of the conjugate field; `repConj_smul_comm` supplies the fibrewise-linearity it needs. The +conjugate half therefore carries `star` of the gauge matrix, which is the physicists' +`ψ̄ ↦ ψ̄ U†`. -/ +noncomputable def JetComponentSpace.repJetGaugeGroupI [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) : + Representation ℂ JetGaugeGroupI (JetComponentSpace V) := + (repDual rep hlin).prod (repDual (repConj rep) (repConj_smul_comm hlin)) + +@[simp] +lemma JetComponentSpace.repJetGaugeGroupI_fst [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x : JetComponentSpace V) : + (JetComponentSpace.repJetGaugeGroupI rep hlin U x).1 = repDual rep hlin U x.1 := rfl + +@[simp] +lemma JetComponentSpace.repJetGaugeGroupI_snd [Module.Free ℂ V] [Module.Finite ℂ V] + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (hlin : ∀ (U : JetGaugeGroupI) (χ : JetRing) (z : JetRing ⊗[ℂ] V), + rep U (χ • z) = χ • rep U z) + (U : JetGaugeGroupI) (x : JetComponentSpace V) : + (JetComponentSpace.repJetGaugeGroupI rep hlin U x).2 + = repDual (repConj rep) (repConj_smul_comm hlin) U x.2 := rfl + +/-! + +## The representation of the Lorentz group + +-/ + + +/-! + +## The Lorentz action on the component space + +-/ + +/-- **The Lorentz action on the jet component space.** Under a Lorentz transformation a +matter field transforms as `ψ(x) ↦ ρ(Λ) ψ(Λ⁻¹ x)`, so a derivative symbol `∂_s ψ_α` is +acted on in *both* of its labels: the derivative multiset `s` by the Lorentz action on +covectors, extended to `DerivAlgebraComplex`, and the target index `α` by the +contragredient of `ρ`. + +Unlike the gauge action, this needs no fibrewise-linearity or finite-dimensionality +hypothesis: the two labels transform independently, so the action is simply a tensor +product of representations. The conjugate half is the same with `ρ` replaced by its +conjugate, the symbols `∂_s ψ̄_α` transforming by `star` of the spinor matrix. -/ +noncomputable def JetComponentSpace.repLorentzGroup + (repV : Representation ℂ SL(2,ℂ) V) : + Representation ℂ SL(2,ℂ) (JetComponentSpace V) := + (DerivAlgebraComplex.repLorentzGroup.tprod repV.dual).prod + (DerivAlgebraComplex.repLorentzGroup.tprod repV.conj.dual) + +@[simp] +lemma JetComponentSpace.repLorentzGroup_fst (repV : Representation ℂ SL(2,ℂ) V) + (Λ : SL(2,ℂ)) (x : JetComponentSpace V) : + (JetComponentSpace.repLorentzGroup repV Λ x).1 + = (DerivAlgebraComplex.repLorentzGroup.tprod repV.dual) Λ x.1 := rfl + +@[simp] +lemma JetComponentSpace.repLorentzGroup_snd (repV : Representation ℂ SL(2,ℂ) V) + (Λ : SL(2,ℂ)) (x : JetComponentSpace V) : + (JetComponentSpace.repLorentzGroup repV Λ x).2 + = (DerivAlgebraComplex.repLorentzGroup.tprod repV.conj.dual) Λ x.2 := rfl + +/-- On a pure symbol the Lorentz action is diagonal in the two labels: the derivative +label transforms in `DerivAlgebraComplex`, the target index contragrediently. -/ +@[simp] +lemma JetComponentSpace.repLorentzGroup_fst_tmul (repV : Representation ℂ SL(2,ℂ) V) + (Λ : SL(2,ℂ)) (a : DerivAlgebraComplex) (φ : Module.Dual ℂ V) + (y : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V)) : + (JetComponentSpace.repLorentzGroup repV Λ (a ⊗ₜ[ℂ] φ, y)).1 + = DerivAlgebraComplex.repLorentzGroup Λ a ⊗ₜ[ℂ] (φ ∘ₗ repV Λ⁻¹) := rfl + +/-! + +## The jet derivative + +-/ + +/-- the derivative of components in the jet component space, + in the direction `μ`: the shift `∂_s ψ_α ↦ ∂_{s + {μ}} ψ_α` of the derivative label, + and likewise on the conjugate components. + + This is right multiplication by the degree-one element `∂_μ` on the + `DerivAlgebraComplex` factor, leaving the target index untouched. It uses a basis of + the Lorentz covectors — that is what the index `μ` is — but no basis of `V`. -/ +noncomputable def JetComponentSpace.jetDeriv (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace V →ₗ[ℂ] JetComponentSpace V := + LinearMap.prodMap + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id) + +@[simp] +lemma JetComponentSpace.jetDeriv_fst_tmul (μ : Fin 1 ⊕ Fin 3) + (a : DerivAlgebraComplex) (φ : Module.Dual ℂ V) + (y : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V)) : + (JetComponentSpace.jetDeriv μ (a ⊗ₜ[ℂ] φ, y)).1 + = (a * DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℂ] φ := rfl + +@[simp] +lemma JetComponentSpace.jetDeriv_snd_tmul (μ : Fin 1 ⊕ Fin 3) + (x : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V) + (a : DerivAlgebraComplex) (φ : Module.Dual ℂ (ConjModule V)) : + (JetComponentSpace.jetDeriv μ (x, a ⊗ₜ[ℂ] φ)).2 + = (a * DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) ⊗ₜ[ℂ] φ := rfl + +/-- **Total derivatives commute.** Mixed partials agree because the derivative labels + live in a *symmetric* algebra; no basis of `V` is involved. -/ +lemma JetComponentSpace.jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (JetComponentSpace.jetDeriv (V := V) μ).comp (JetComponentSpace.jetDeriv ν) + = (JetComponentSpace.jetDeriv (V := V) ν).comp (JetComponentSpace.jetDeriv μ) := by + have hmul : ∀ b c : DerivAlgebraComplex, + (LinearMap.mulRight ℂ b).comp (LinearMap.mulRight ℂ c) + = LinearMap.mulRight ℂ (c * b) := + fun b c => LinearMap.ext fun x => by + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.mulRight_apply, mul_assoc] + rw [JetComponentSpace.jetDeriv, JetComponentSpace.jetDeriv, LinearMap.prodMap_comp, + LinearMap.prodMap_comp, ← TensorProduct.map_comp, ← TensorProduct.map_comp, + ← TensorProduct.map_comp, ← TensorProduct.map_comp, hmul, hmul, mul_comm] + +/-- The element being multiplied in is the degree-one derivative symbol `∂_μ`, the image + of the dual basis covector under `SymmetricAlgebra.ι`. -/ +lemma JetComponentSpace.jetDeriv_eq_ι (μ : Fin 1 ⊕ Fin 3) : + JetComponentSpace.jetDeriv (V := V) μ + = LinearMap.prodMap + (TensorProduct.map + (LinearMap.mulRight ℂ (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ))) LinearMap.id) + (TensorProduct.map + (LinearMap.mulRight ℂ (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ))) LinearMap.id) := by + rw [JetComponentSpace.jetDeriv, DerivAlgebraComplex.basis_singleton] + +@[simp] +lemma JetComponentSpace.jetDeriv_fst (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace V) : + (JetComponentSpace.jetDeriv μ v).1 + = TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id v.1 := rfl + +@[simp] +lemma JetComponentSpace.jetDeriv_snd (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace V) : + (JetComponentSpace.jetDeriv μ v).2 + = TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id v.2 := rfl + +/-! + +## Lorentz covariance of the jet derivative + +-/ + +/-- The covariance of the derivative-symbol multiplication on one tensor factor of the + component space, for an arbitrary representation on the other factor. -/ +private lemma repLorentzGroup_tprod_mulRight_jetSymbol {W : Type*} [AddCommGroup W] + [Module ℂ W] (ρ : Representation ℂ SL(2,ℂ) W) (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) + (w : DerivAlgebraComplex ⊗[ℂ] W) : + (DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ + (TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id w) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + TensorProduct.map + (LinearMap.mulRight ℂ (DerivAlgebraComplex.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)))) + LinearMap.id ((DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ w) := by + have hsym : DerivAlgebraComplex.repLorentzGroup Λ + (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + DerivAlgebraComplex.basis ({a} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [DerivAlgebraComplex.basis_singleton, DerivAlgebraComplex.repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, map_sum] + exact Finset.sum_congr rfl fun a _ => by + rw [map_smul, DerivAlgebraComplex.basis_singleton] + have hrep : ∀ (q : DerivAlgebraComplex) (f : W), + (DerivAlgebraComplex.repLorentzGroup.tprod ρ) Λ (q ⊗ₜ[ℂ] f) = + (DerivAlgebraComplex.repLorentzGroup Λ q) ⊗ₜ[ℂ] (ρ Λ f) := fun _ _ => rfl + induction w using TensorProduct.induction_on with + | zero => simp + | add x y hx hy => + rw [map_add, map_add, map_add, hx, hy, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun a _ => by rw [map_add, smul_add] + | tmul q f => + rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, LinearMap.id_apply, hrep, hrep, + DerivAlgebraComplex.repLorentzGroup_apply_mul, hsym, Finset.mul_sum, + TensorProduct.sum_tmul] + exact Finset.sum_congr rfl fun a _ => by + rw [TensorProduct.map_tmul, LinearMap.mulRight_apply, LinearMap.id_apply, + mul_smul_comm, TensorProduct.smul_tmul'] + +/-- **The jet derivative is a Lorentz vector on the component space.** Appending `∂_μ` and + then acting is acting and then appending the transformed `∂_μ`, which is a combination of + the `∂_a`. Both halves of the component space are covered by the same argument: the + derivative label lives in the first tensor factor, and what sits in the second factor — + `repV.dual` or `repV.conj.dual` — plays no role. -/ +lemma JetComponentSpace.repLorentzGroup_jetDeriv (repV : Representation ℂ SL(2,ℂ) V) + (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (v : JetComponentSpace V) : + JetComponentSpace.repLorentzGroup repV Λ (JetComponentSpace.jetDeriv μ v) = + ∑ a, (((Lorentz.SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • + JetComponentSpace.jetDeriv a (JetComponentSpace.repLorentzGroup repV Λ v) := by + refine Prod.ext ?_ ?_ + · simp only [Prod.fst_sum, Prod.smul_fst, JetComponentSpace.repLorentzGroup_fst, + JetComponentSpace.jetDeriv_fst] + exact repLorentzGroup_tprod_mulRight_jetSymbol _ Λ μ v.1 + · simp only [Prod.snd_sum, Prod.smul_snd, JetComponentSpace.repLorentzGroup_snd, + JetComponentSpace.jetDeriv_snd] + exact repLorentzGroup_tprod_mulRight_jetSymbol _ Λ μ v.2 + +/-! + +## Functoriality in the target space + +-/ + +variable {W : Type _} [AddCommGroup W] [Module ℂ W] + +/-- **The component space is contravariant in the target space.** A linear map `f : V →ₗ W` + of target spaces pulls the component functions of a `W`-valued field back to component + functions of a `V`-valued field: a component function is a *covector* on the target, so it + transposes. The derivative label is untouched, and the conjugate half transposes the + conjugate of `f`. -/ +noncomputable def JetComponentSpace.comap (f : V →ₗ[ℂ] W) : + JetComponentSpace W →ₗ[ℂ] JetComponentSpace V := + LinearMap.prodMap + (TensorProduct.map LinearMap.id (Module.Dual.transpose f)) + (TensorProduct.map LinearMap.id (Module.Dual.transpose (ConjModule.map f))) + +@[simp] +lemma JetComponentSpace.comap_fst_tmul (f : V →ₗ[ℂ] W) (a : DerivAlgebraComplex) + (φ : Module.Dual ℂ W) (y : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule W)) : + (JetComponentSpace.comap f (a ⊗ₜ[ℂ] φ, y)).1 = a ⊗ₜ[ℂ] (φ ∘ₗ f) := rfl + +@[simp] +lemma JetComponentSpace.comap_snd_tmul (f : V →ₗ[ℂ] W) + (x : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ W) (a : DerivAlgebraComplex) + (φ : Module.Dual ℂ (ConjModule W)) : + (JetComponentSpace.comap f (x, a ⊗ₜ[ℂ] φ)).2 = a ⊗ₜ[ℂ] (φ ∘ₗ ConjModule.map f) := rfl + +@[simp] +lemma JetComponentSpace.comap_id : + JetComponentSpace.comap (LinearMap.id : V →ₗ[ℂ] V) = LinearMap.id := by + rw [JetComponentSpace.comap, + show Module.Dual.transpose (LinearMap.id : V →ₗ[ℂ] V) = LinearMap.id from rfl, + show ConjModule.map (LinearMap.id : V →ₗ[ℂ] V) = LinearMap.id from rfl, + show Module.Dual.transpose (LinearMap.id : ConjModule V →ₗ[ℂ] ConjModule V) + = LinearMap.id from rfl, TensorProduct.map_id, TensorProduct.map_id] + rfl + +/-- Functoriality: pulling back along `g ∘ f` is pulling back along `g` and then along `f`. + The order reverses, as it must for a contravariant construction. -/ +lemma JetComponentSpace.comap_comp {U : Type _} [AddCommGroup U] [Module ℂ U] + (f : V →ₗ[ℂ] W) (g : W →ₗ[ℂ] U) : + JetComponentSpace.comap (g.comp f) + = (JetComponentSpace.comap f).comp (JetComponentSpace.comap g) := by + rw [JetComponentSpace.comap, JetComponentSpace.comap, JetComponentSpace.comap, + LinearMap.prodMap_comp, ← TensorProduct.map_comp, ← TensorProduct.map_comp, + LinearMap.id_comp] + rfl + +/-- **The pullback commutes with the jet derivative.** The two act on different tensor + factors — the derivative label and the target index — so an inclusion of species is a map + of differential algebras. -/ +lemma JetComponentSpace.comap_jetDeriv (f : V →ₗ[ℂ] W) (μ : Fin 1 ⊕ Fin 3) : + (JetComponentSpace.comap f).comp (JetComponentSpace.jetDeriv μ) + = (JetComponentSpace.jetDeriv μ).comp (JetComponentSpace.comap f) := by + rw [JetComponentSpace.comap, JetComponentSpace.jetDeriv, JetComponentSpace.jetDeriv, + LinearMap.prodMap_comp, LinearMap.prodMap_comp, ← TensorProduct.map_comp, + ← TensorProduct.map_comp, ← TensorProduct.map_comp, ← TensorProduct.map_comp] + simp only [LinearMap.comp_id, LinearMap.id_comp] + +/-! + +## The mass-weight scaling + +The mass dimension is tracked multiplicatively, through a scaling action: for a field of +*mass weight* `w` — twice the mass dimension, kept integral so that fermions of dimension +`3/2` carry weight `3` — the generator `∂_s φ_α` scales by `c ^ (w + 2 |s|)`, one factor +of `c ^ 2` per derivative. The scaling on the component space below lifts functorially to +the bosonic and fermionic algebras, where it defines their mass-dimension grading. + +-/ + +/-- The mass-weight scaling on the jet component space of a field of mass weight `w` + (twice the mass dimension): the generator `∂_s φ_α` and its conjugate are scaled by + `c ^ (w + 2 |s|)`, through the derivative-degree scaling `DerivAlgebraComplex.gradeScale` + on the derivative label. -/ +noncomputable def JetComponentSpace.massWeightScale (w : ℕ) (c : ℂ) : + JetComponentSpace V →ₗ[ℂ] JetComponentSpace V := + c ^ w • LinearMap.prodMap + (TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap LinearMap.id) + (TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap LinearMap.id) + +/-- On an unconjugated component function `∂_s φ_α` the mass-weight scaling is + multiplication by `c ^ (w + 2 |s|)`. -/ +lemma JetComponentSpace.massWeightScale_fst_basis_tmul (w : ℕ) (c : ℂ) + (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) + (y : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V)) : + (JetComponentSpace.massWeightScale w c + ((DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ, y) : JetComponentSpace V)).1 + = c ^ (w + 2 * Multiset.card s) • (DerivAlgebraComplex.basis s ⊗ₜ[ℂ] φ) := by + simp only [massWeightScale, LinearMap.smul_apply, Prod.smul_fst, LinearMap.prodMap_apply, + TensorProduct.map_tmul, AlgHom.toLinearMap_apply, DerivAlgebraComplex.gradeScale_basis, + LinearMap.id_apply, TensorProduct.smul_tmul', ← pow_mul, pow_add, mul_smul, + mul_comm 2 (Multiset.card s)] + +@[simp] +lemma JetComponentSpace.massWeightScale_fst (w : ℕ) (c : ℂ) (v : JetComponentSpace V) : + (JetComponentSpace.massWeightScale w c v).1 + = c ^ w • TensorProduct.map + (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap LinearMap.id v.1 := rfl + +@[simp] +lemma JetComponentSpace.massWeightScale_snd (w : ℕ) (c : ℂ) (v : JetComponentSpace V) : + (JetComponentSpace.massWeightScale w c v).2 + = c ^ w • TensorProduct.map + (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap LinearMap.id v.2 := rfl + +/-- The derivative-degree scaling intertwines multiplication by a single derivative + symbol up to one factor of the scaling parameter, on either half of the component + space. -/ +private lemma gradeScale_map_mulRight_basis {W : Type*} [AddCommGroup W] [Module ℂ W] + (c : ℂ) (μ : Fin 1 ⊕ Fin 3) (x : DerivAlgebraComplex ⊗[ℂ] W) : + TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap LinearMap.id + (TensorProduct.map (LinearMap.mulRight ℂ + (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) LinearMap.id x) + = c ^ 2 • TensorProduct.map (LinearMap.mulRight ℂ + (DerivAlgebraComplex.basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)))) LinearMap.id + (TensorProduct.map (DerivAlgebraComplex.gradeScale (c ^ 2)).toLinearMap + LinearMap.id x) := by + induction x using TensorProduct.induction_on with + | zero => simp only [map_zero, smul_zero] + | add a b ha hb => simp only [map_add, ha, hb, smul_add] + | tmul a y => + simp only [TensorProduct.map_tmul, LinearMap.mulRight_apply, LinearMap.id_apply, + AlgHom.toLinearMap_apply, map_mul, DerivAlgebraComplex.gradeScale_basis, + Multiset.card_singleton, pow_one, mul_smul_comm, TensorProduct.smul_tmul'] + +/-- **The total derivative carries mass weight two** on the component space: the scaling + intertwines the derivative shift up to a factor `c ^ 2`. -/ +lemma JetComponentSpace.massWeightScale_jetDeriv (w : ℕ) (c : ℂ) (μ : Fin 1 ⊕ Fin 3) : + (JetComponentSpace.massWeightScale (V := V) w c).comp (JetComponentSpace.jetDeriv μ) + = c ^ 2 • (JetComponentSpace.jetDeriv μ).comp + (JetComponentSpace.massWeightScale w c) := by + have key := fun {W : Type _} [AddCommGroup W] [Module ℂ W] + (x : DerivAlgebraComplex ⊗[ℂ] W) => gradeScale_map_mulRight_basis c μ x + refine LinearMap.ext fun v => Prod.ext ?_ ?_ + · simp only [LinearMap.comp_apply, LinearMap.smul_apply, Prod.smul_fst, + JetComponentSpace.massWeightScale_fst, JetComponentSpace.jetDeriv_fst, map_smul] + exact (congrArg (fun z : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ V => c ^ w • z) + (key v.1)).trans (smul_comm _ _ _) + · simp only [LinearMap.comp_apply, LinearMap.smul_apply, Prod.smul_snd, + JetComponentSpace.massWeightScale_snd, JetComponentSpace.jetDeriv_snd, map_smul] + exact (congrArg (fun z : DerivAlgebraComplex ⊗[ℂ] Module.Dual ℂ (ConjModule V) => + c ^ w • z) (key v.2)).trans (smul_comm _ _ _) + +/-! + +## The component space of a direct sum + +-/ + +/-- **The component space of a direct sum splits.** The component functions of a + `(V × W)`-valued field are those of a `V`-valued field together with those of a + `W`-valued field: the dual and the conjugate both distribute over the finite product, and + the derivative label is untouched. -/ +noncomputable def JetComponentSpace.prodEquiv (V W : Type) [AddCommGroup V] [Module ℂ V] + [AddCommGroup W] [Module ℂ W] : + JetComponentSpace (V × W) ≃ₗ[ℂ] JetComponentSpace V × JetComponentSpace W := + (LinearEquiv.prodCongr + (TensorProduct.congr (LinearEquiv.refl ℂ DerivAlgebraComplex) + (Module.dualProdDualEquivDual ℂ V W).symm) + (TensorProduct.congr (LinearEquiv.refl ℂ DerivAlgebraComplex) + (((ConjModule.prodEquiv (k := ℂ) (M := V) (N := W)).symm.dualMap).trans + (Module.dualProdDualEquivDual ℂ (ConjModule V) (ConjModule W)).symm))).trans <| + (LinearEquiv.prodCongr (TensorProduct.prodRight ℂ ℂ _ _ _) + (TensorProduct.prodRight ℂ ℂ _ _ _)).trans + (LinearEquiv.prodProdProdComm ℂ _ _ _ _) + +end StandardModel diff --git a/Physlib/Particles/StandardModel/Matter/JetComponentSpace/CovariantDeriv.lean b/Physlib/Particles/StandardModel/Matter/JetComponentSpace/CovariantDeriv.lean new file mode 100644 index 000000000..c6f2d560e --- /dev/null +++ b/Physlib/Particles/StandardModel/Matter/JetComponentSpace/CovariantDeriv.lean @@ -0,0 +1,764 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.Basic +public import Physlib.Particles.StandardModel.GaugeBosons.AlgebraValued.TransformsInAdjoint +public import Mathlib.LinearAlgebra.Basis.Defs +public import Mathlib.LinearAlgebra.Dimension.Free +/-! + +# Gauge tensors in a general representation + +The adjoint story of `TransformsInAdjoint` generalizes to an arbitrary representation +of the jet gauge group: a matter field valued in a representation space `V` has +symbols `[∂_s ψ^i]` contracted against duals of `V`, and its transformation law is +the Leibniz convolution of the base-point Taylor coefficients of the representation. + +Since the gauge transformations are jets, the representation must act on `V`-valued +jets `JetRing ⊗[ℂ] V` — the value of `rep U` at a constant vector is spacetime +dependent, and the derivative symbols see its Taylor coefficients. This file provides +the toolkit for `V`-valued jets: + +* `jetOfConstant` — the inclusion of constants, `v ↦ 1 ⊗ v`; +* `jetDeriv`/`jetIteratedDeriv` — the formal derivative, acting on the jet factor; +* `jetEval` — evaluation at the base point, `f ⊗ v ↦ (constant coefficient of f) • v`; + +and with them + +* `repDualCoeff rep U x` — the physicists' `∂_x (rep U)^i_j|₀` transposed to the dual + of `V`, the analogue of `adjointDualCoeff` for a general representation; +* `TransformsIn` — the generalization of `TransformsInAdjoint`: the derivative + symbols of the family transform by the Leibniz convolution of `repDualCoeff`, with + no inhomogeneous term. + +## The covariant derivative + +The covariant derivative `∇_ρ F = D_ρ F + (A_ρ acting on the value index)` requires +the *infinitesimal* action of the gauge algebra on the value space — physicists' +`i dρ(T^a)` — which cannot be extracted from the abstract group representation `rep` +(there is no differentiable structure to differentiate it). It is therefore taken as +data: an `ℝ`-bilinear action `act : GaugeAlgebra →ₗ[ℝ] W →ₗ[ℝ] W`. The layer is +built for an arbitrary finite-dimensional real value space `W`, so that the adjoint +case `act = adAction` (the bracket as a bilinear map) literally specializes: +`covDerivAction A adAction F D ρ = covDerivAdjoint A F D ρ` holds definitionally +(`covDerivAction_adAction`). + +The compatibility between `rep` and `act` — the structure `IsInfinitesimalActionOf` — +and the theorem that under it the covariant derivative preserves the gauge tensors live +in `Physlib.Particles.StandardModel.GaugeAlgebra.InfinitesimalAction`. + +-/ + +@[expose] public section + +namespace StandardModel +open Matrix MatrixGroups TensorProduct MvPowerSeries +variable {B : Type} [Ring B] [Algebra ℂ B] +variable {V : Type} [AddCommGroup V] [Module ℂ V] + +/-! + +## `V`-valued jets + +-/ + +/-- The constant-coefficient evaluation of a jet, as a `ℂ`-linear map. -/ +noncomputable def _root_.JetRing.constantCoeffₗ : JetRing →ₗ[ℂ] ℂ where + toFun := constantCoeff + map_add' f g := by simp + map_smul' c f := by simp [smul_eq_C_mul] + +@[simp] +lemma _root_.JetRing.constantCoeffₗ_apply (f : JetRing) : + JetRing.constantCoeffₗ f = constantCoeff f := rfl + +/-- The inclusion of constants into `V`-valued jets: `v ↦ 1 ⊗ v`. -/ +noncomputable def jetOfConstant : V →ₗ[ℂ] JetRing ⊗[ℂ] V := + TensorProduct.mk ℂ JetRing V 1 + +@[simp] +lemma jetOfConstant_apply (v : V) : jetOfConstant v = (1 : JetRing) ⊗ₜ[ℂ] v := rfl + +/-- The formal derivative on `V`-valued jets in the direction `μ`, acting on the jet + factor. -/ +noncomputable def jetDeriv (μ : Fin 1 ⊕ Fin 3) : + JetRing ⊗[ℂ] V →ₗ[ℂ] JetRing ⊗[ℂ] V := + LinearMap.rTensor V (pderiv ℂ μ).toLinearMap + +@[simp] +lemma jetDeriv_tmul (μ : Fin 1 ⊕ Fin 3) (f : JetRing) (v : V) : + jetDeriv μ (f ⊗ₜ[ℂ] v) = pderiv ℂ μ f ⊗ₜ[ℂ] v := rfl + +/-- Formal derivatives on `V`-valued jets commute, since the partial derivatives of + jets do. -/ +lemma jetDeriv_comm (μ ν : Fin 1 ⊕ Fin 3) : + (jetDeriv (V := V) μ).comp (jetDeriv ν) = (jetDeriv ν).comp (jetDeriv μ) := by + rw [jetDeriv, jetDeriv, ← LinearMap.rTensor_comp, ← LinearMap.rTensor_comp] + exact congrArg (LinearMap.rTensor V) + (LinearMap.ext fun f => JetRing.pderiv_comm μ ν f) + +/-- Post-composition with `jetDeriv` is right-commutative, which is what allows + iterated derivatives to be indexed by a `Multiset` of directions. -/ +instance : RightCommutative (fun (L : JetRing ⊗[ℂ] V →ₗ[ℂ] JetRing ⊗[ℂ] V) + (μ : Fin 1 ⊕ Fin 3) => L.comp (jetDeriv μ)) where + right_comm L μ ν := by + refine LinearMap.ext fun x => ?_ + have h := LinearMap.congr_fun (jetDeriv_comm μ ν) x + simp only [LinearMap.coe_comp, Function.comp_apply] at h ⊢ + exact congrArg L h + +/-- The iterated formal derivative on `V`-valued jets, in the (unordered) directions + given by the multiset `μs`. -/ +noncomputable def jetIteratedDeriv (μs : Multiset (Fin 1 ⊕ Fin 3)) : + JetRing ⊗[ℂ] V →ₗ[ℂ] JetRing ⊗[ℂ] V := + μs.foldl (fun L μ => L.comp (jetDeriv μ)) LinearMap.id + +@[simp] +lemma jetIteratedDeriv_zero : + jetIteratedDeriv (V := V) (0 : Multiset (Fin 1 ⊕ Fin 3)) = LinearMap.id := by + simp [jetIteratedDeriv] + +lemma jetIteratedDeriv_cons (μ : Fin 1 ⊕ Fin 3) (μs : Multiset (Fin 1 ⊕ Fin 3)) : + jetIteratedDeriv (V := V) (μ ::ₘ μs) = (jetDeriv μ).comp (jetIteratedDeriv μs) := by + have h : ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (L : JetRing ⊗[ℂ] V →ₗ[ℂ] JetRing ⊗[ℂ] V), + s.foldl (fun L μ => L.comp (jetDeriv μ)) L = L.comp (jetIteratedDeriv s) := by + intro s + induction s using Multiset.induction_on with + | empty => intro L; simp [jetIteratedDeriv] + | cons κ t ih => + intro L + rw [jetIteratedDeriv, Multiset.foldl_cons, Multiset.foldl_cons, ih, ih] + simp [LinearMap.comp_assoc] + rw [jetIteratedDeriv, Multiset.foldl_cons, h] + simp + +/-- The iterated derivative is additive in the multiset of directions. -/ +lemma jetIteratedDeriv_add (s t : Multiset (Fin 1 ⊕ Fin 3)) : + jetIteratedDeriv (V := V) (s + t) = + (jetIteratedDeriv s).comp (jetIteratedDeriv t) := by + induction s using Multiset.induction_on with + | empty => simp + | cons μ s ih => + rw [Multiset.cons_add, jetIteratedDeriv_cons, jetIteratedDeriv_cons, ih, + LinearMap.comp_assoc] + +@[simp] +lemma jetIteratedDeriv_singleton (μ : Fin 1 ⊕ Fin 3) : + jetIteratedDeriv (V := V) ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = jetDeriv μ := by + rw [show ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = μ ::ₘ 0 from rfl, jetIteratedDeriv_cons, + jetIteratedDeriv_zero, LinearMap.comp_id] + +/-- Evaluation of a `V`-valued jet at the base point: + `f ⊗ v ↦ (constant coefficient of f) • v`. This is a retraction of + `jetOfConstant`. -/ +noncomputable def jetEval : JetRing ⊗[ℂ] V →ₗ[ℂ] V := + TensorProduct.lift ((LinearMap.lsmul ℂ V).comp JetRing.constantCoeffₗ) + +@[simp] +lemma jetEval_tmul (f : JetRing) (v : V) : + jetEval (f ⊗ₜ[ℂ] v) = constantCoeff f • v := rfl + +@[simp] +lemma jetEval_jetOfConstant (v : V) : jetEval (jetOfConstant v) = v := by + simp + +namespace IsGaugeField + +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {repLorentz : Representation ℂ SL(2,ℂ) B} +variable {repGauge : Representation ℂ JetGaugeGroupI B} +variable {A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + +/-! + +## The dual representation coefficients and gauge tensors in a representation + +-/ + +/-- The base-point adjoint transport at `x` derivatives, un-dualized: the map on the + gauge algebra whose transpose is `adjointDualCoeff`. -/ +noncomputable def adjointCoeff (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + GaugeAlgebra →ₗ[ℝ] GaugeAlgebra := + JetGaugeAlgebra.eval.toLinearMap ∘ₗ JetGaugeAlgebra.iteratedDeriv x ∘ₗ + JetGaugeAlgebra.adjointMap U ∘ₗ JetGaugeAlgebra.ofConstant + +lemma adjointDualCoeff_eq_dualMap (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + adjointDualCoeff U x = (adjointCoeff U x).dualMap := rfl + +/-- The base-point Taylor coefficient of the representation: include the constant + vector into `V`-valued jets, act by `rep U`, differentiate `x` times, evaluate at + the base point. The composite is complex-linear: the physicists' + `∂_x (rep U)^i_j|₀` as a ℂ-linear map on the value space. -/ +noncomputable def repCoeff (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : V →ₗ[ℂ] V := + jetEval ∘ₗ jetIteratedDeriv x ∘ₗ rep U ∘ₗ jetOfConstant + +/-- The physicists' `∂_x (rep U)^i_j|₀` acting on the complex dual index of a + matter-field symbol: the transpose of `repCoeff`. This is the analogue of + `adjointDualCoeff` for a general representation of the jet gauge group; for `x = 0` + it is the dual (contragredient) action of the value of `U`, and for `x ≠ 0` it sees + the derivatives of the gauge transformation. -/ +noncomputable def repDualCoeff (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (U : JetGaugeGroupI) (x : Multiset (Fin 1 ⊕ Fin 3)) : + Module.Dual ℂ V →ₗ[ℂ] Module.Dual ℂ V := + (repCoeff rep U x).dualMap + +/-- A component family `F`, valued in `B` and indexed by the complex dual of the + representation space `V`, *transforms in* the representation `rep` of the jet gauge + group — with the ambient action `repGauge` on `B` — when each derivative symbol + `[∂_s F^φ]` transforms by the Leibniz convolution of the dual representation + coefficients against lower symbols, with no inhomogeneous term — the generalization + of `TransformsInAdjoint` from the adjoint representation to an arbitrary one, and + the form consumed by `IsStandardModel`. -/ +def _root_.StandardModel.TransformsIn (repGauge : Representation ℂ JetGaugeGroupI B) + (rep : Representation ℂ JetGaugeGroupI (JetRing ⊗[ℂ] V)) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) : Prop := + ∀ (U : JetGaugeGroupI) (φ : Module.Dual ℂ V) (s : Multiset (Fin 1 ⊕ Fin 3)), + repGauge U (F s φ) = + (s.antidiagonal.map fun p => F p.2 (repDualCoeff rep U⁻¹ p.1 φ)).sum + +/-! + +## The covariant derivative through an infinitesimal action + +The covariant derivative `∇_ρ F = [∂_ρ F] + A_ρ · F` requires the *infinitesimal* +action of the gauge algebra on the value space — physicists' `i dρ(T^a)` — which +cannot be extracted from the abstract group representation `rep` (there is no +differentiable structure to differentiate it). It is therefore taken as data: an +action `act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V`, real-linear in the algebra slot (the +gauge algebra is a real Lie algebra) and complex-linear in the value slot, matching +the complex duals indexing the matter families. + +-/ + +section Action + +variable {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} + +/-- The action of an adjoint-valued field on a matter field at the tensor level: + multiplication in `B` on the first factors, the ℂ-linear infinitesimal action `act` + of the gauge algebra on `V` on the second, so that on pure tensors + `(b₁ ⊗ c) · (b₂ ⊗ v) = (b₁ b₂) ⊗ act c v`. -/ +noncomputable def tensorAction (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) : + (B ⊗[ℝ] GaugeAlgebra) →ₗ[ℝ] (B ⊗[ℂ] V) →ₗ[ℂ] B ⊗[ℂ] V := + TensorProduct.lift + { toFun := fun b₁ => + { toFun := fun c => TensorProduct.map (LinearMap.mulLeft ℂ b₁) (act c) + map_add' := fun c₁ c₂ => TensorProduct.ext' fun b₂ v => by + simp [TensorProduct.tmul_add] + map_smul' := fun r c => TensorProduct.ext' fun b₂ v => by + simp [TensorProduct.tmul_smul] } + map_add' := fun b₁ b₁' => LinearMap.ext fun c => TensorProduct.ext' fun b₂ v => by + simp [add_mul, TensorProduct.add_tmul] + map_smul' := fun r b₁ => LinearMap.ext fun c => TensorProduct.ext' fun b₂ v => by + simp [TensorProduct.smul_tmul'] } + +@[simp] +lemma tensorAction_tmul (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (b₁ b₂ : B) + (c : GaugeAlgebra) (v : V) : + tensorAction act (b₁ ⊗ₜ[ℝ] c) (b₂ ⊗ₜ[ℂ] v) = (b₁ * b₂) ⊗ₜ[ℂ] act c v := rfl + +lemma tensorAction_map_left (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (Φ : B →ₗ[ℂ] B) + (hΦ : ∀ b₁ b₂, Φ (b₁ * b₂) = Φ b₁ * Φ b₂) (s : B ⊗[ℝ] GaugeAlgebra) + (t : B ⊗[ℂ] V) : + tensorAction act ((TensorProduct.map (Φ.restrictScalars ℝ) LinearMap.id) s) + ((TensorProduct.map Φ LinearMap.id) t) = + (TensorProduct.map Φ LinearMap.id) (tensorAction act s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => simp [hΦ] + | add x y hx hy => + simp only [map_add] + rw [hx, hy] + | add x y hx hy => simp [hx, hy] + +lemma tensorAction_one_left (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (c : GaugeAlgebra) + (t : B ⊗[ℂ] V) : + tensorAction act ((1 : B) ⊗ₜ[ℝ] c) t = + (TensorProduct.map LinearMap.id (act c)) t := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b a => simp + | add x y hx hy => simp [hx, hy] + +/-- `tensorAction` under an antidiagonal pair of transport families: if the + `V`-transports intertwine `act` with the `GaugeAlgebra`-transports as an + antidiagonal convolution, so do `id ⊗ ·` over `tensorAction`. -/ +lemma tensorAction_map_right_antidiagonal (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (Tg : Multiset (Fin 1 ⊕ Fin 3) → GaugeAlgebra →ₗ[ℝ] GaugeAlgebra) + (Tv : Multiset (Fin 1 ⊕ Fin 3) → V →ₗ[ℂ] V) (x : Multiset (Fin 1 ⊕ Fin 3)) + (hT : ∀ (c : GaugeAlgebra) (w : V), Tv x (act c w) = + (x.antidiagonal.map fun p => act (Tg p.1 c) (Tv p.2 w)).sum) + (s : B ⊗[ℝ] GaugeAlgebra) (t : B ⊗[ℂ] V) : + (x.antidiagonal.map fun p => + tensorAction act ((TensorProduct.map LinearMap.id (Tg p.1)) s) + ((TensorProduct.map LinearMap.id (Tv p.2)) t)).sum = + (TensorProduct.map LinearMap.id (Tv x)) (tensorAction act s t) := by + induction s using TensorProduct.induction_on with + | zero => simp + | tmul b₁ a₁ => + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b₂ a₂ => + simp only [tensorAction_tmul, TensorProduct.map_tmul, LinearMap.id_coe, id_eq] + rw [hT, Multiset.tmul_sum, Multiset.map_map] + exact congrArg Multiset.sum (Multiset.map_congr rfl fun p hp => by + simp) + | add y z hy hz => + rw [Multiset.map_congr rfl (fun p hp => by rw [map_add, map_add]), + Multiset.sum_map_add, hy, hz, ← map_add, ← map_add] + | add y z hy hz => + rw [Multiset.map_congr rfl (fun p hp => by + rw [map_add, map_add, LinearMap.add_apply]), + Multiset.sum_map_add, hy, hz, ← map_add, ← LinearMap.add_apply, ← map_add] + +variable [FiniteDimensional ℂ V] + +/-- The canonical equivalence between matter fields `B ⊗[ℂ] V` and their component + families `φ ↦ F^φ` over the complex dual — `dualPairEquiv` for a general + finite-dimensional complex value space. -/ +noncomputable def dualPairEquivC : (B ⊗[ℂ] V) ≃ₗ[ℂ] (Module.Dual ℂ V →ₗ[ℂ] B) := + TensorProduct.comm ℂ B V ≪≫ₗ + TensorProduct.congr (Module.evalEquiv ℂ V) (LinearEquiv.refl ℂ B) ≪≫ₗ + dualTensorHomEquiv ℂ (Module.Dual ℂ V) B + +@[simp] +lemma dualPairEquivC_tmul (b : B) (v : V) (φ : Module.Dual ℂ V) : + dualPairEquivC (b ⊗ₜ[ℂ] v) φ = φ v • b := by + simp [dualPairEquivC, dualTensorHomEquiv, Module.evalEquiv_apply] + +lemma dualPairEquivC_map_left (Φ : B →ₗ[ℂ] B) (t : B ⊗[ℂ] V) + (φ : Module.Dual ℂ V) : + dualPairEquivC ((TensorProduct.map Φ LinearMap.id) t) φ = + Φ (dualPairEquivC t φ) := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b w => simp + | add x y hx hy => simp [hx, hy] + +lemma dualPairEquivC_map_right (T : V →ₗ[ℂ] V) (t : B ⊗[ℂ] V) + (φ : Module.Dual ℂ V) : + dualPairEquivC ((TensorProduct.map LinearMap.id T) t) φ = + dualPairEquivC t (T.dualMap φ) := by + induction t using TensorProduct.induction_on with + | zero => simp + | tmul b w => simp + | add x y hx hy => simp [hx, hy] + +lemma symm_comp_left_C (Φ : B →ₗ[ℂ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B) : + dualPairEquivC.symm (Φ ∘ₗ g) = + (TensorProduct.map Φ LinearMap.id) (dualPairEquivC.symm g) := by + apply dualPairEquivC.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + rw [dualPairEquivC_map_left, LinearEquiv.apply_symm_apply] + rfl + +lemma symm_comp_right_C (T : V →ₗ[ℂ] V) (g : Module.Dual ℂ V →ₗ[ℂ] B) : + dualPairEquivC.symm (g ∘ₗ T.dualMap) = + (TensorProduct.map LinearMap.id T) (dualPairEquivC.symm g) := by + apply dualPairEquivC.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + rw [dualPairEquivC_map_right, LinearEquiv.apply_symm_apply] + rfl + +/-- The action of an adjoint-indexed component family on a matter one, through the + infinitesimal action `act`: assemble both into fields, act by `tensorAction`, read + back out as components. This is the physicists' `f^a (T_a)^i_j g^j` with `T = act`, + basis-free. -/ +noncomputable def actionFam (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) (g : Module.Dual ℂ V →ₗ[ℂ] B) : + Module.Dual ℂ V →ₗ[ℂ] B := + dualPairEquivC (tensorAction act (dualPairEquiv.symm f) (dualPairEquivC.symm g)) + +lemma actionFam_add_left (f₁ f₂ : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (g : Module.Dual ℂ V →ₗ[ℂ] B) : + actionFam act (f₁ + f₂) g = actionFam act f₁ g + actionFam act f₂ g := by + simp only [actionFam, map_add, LinearMap.add_apply] + +lemma actionFam_add_right (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (g₁ g₂ : Module.Dual ℂ V →ₗ[ℂ] B) : + actionFam act f (g₁ + g₂) = actionFam act f g₁ + actionFam act f g₂ := by + simp only [actionFam, map_add] + +lemma actionFam_zero_left (g : Module.Dual ℂ V →ₗ[ℂ] B) : + actionFam act 0 g = 0 := by + simp [actionFam] + +lemma actionFam_zero_right (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + actionFam act f 0 = 0 := by + simp [actionFam] + +lemma actionFam_sum_left (S : Multiset (Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B)) + (g : Module.Dual ℂ V →ₗ[ℂ] B) : + actionFam act S.sum g = (S.map fun f => actionFam act f g).sum := by + induction S using Multiset.induction_on with + | empty => simp [actionFam_zero_left] + | cons f S ih => simp [actionFam_add_left, ih] + +lemma actionFam_sum_right (f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (S : Multiset (Module.Dual ℂ V →ₗ[ℂ] B)) : + actionFam act f S.sum = (S.map fun g => actionFam act f g).sum := by + induction S using Multiset.induction_on with + | empty => simp [actionFam_zero_right] + | cons g S ih => simp [actionFam_add_right, ih] + +set_option maxHeartbeats 1000000 in +/-- The gauge transformation of the action of an affinely-transforming + adjoint-indexed family on a linearly-transforming matter family: the action of the + transformed families plus one `act`-type cross term. This is `repGauge_bracketFam` + with a homogeneous second slot and the bracket replaced by a general action. -/ +lemma repGauge_actionFam (hA : IsGaugeField repLorentz repGauge A) + (U : JetGaugeGroupI) {f f' : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} + {g g' : Module.Dual ℂ V →ₗ[ℂ] B} {cf : GaugeAlgebra} + (hf : ∀ ψ : Module.Dual ℝ GaugeAlgebra, + repGauge U (f ψ) = f' ψ + algebraMap ℂ B (ψ cf)) + (hg : ∀ ψ : Module.Dual ℂ V, repGauge U (g ψ) = g' ψ) + (φ : Module.Dual ℂ V) : + repGauge U (actionFam act f g φ) = + actionFam act f' g' φ + g' (φ ∘ₗ act cf) := by + set Φ : B →ₗ[ℂ] B := repGauge U with hΦdef + have hΦmul : ∀ b₁ b₂ : B, Φ (b₁ * b₂) = Φ b₁ * Φ b₂ := fun b₁ b₂ => + hA.gauge_mul U b₁ b₂ + set s : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm f with hs + set t : B ⊗[ℂ] V := dualPairEquivC.symm g with ht + set s' : B ⊗[ℝ] GaugeAlgebra := dualPairEquiv.symm f' with hs' + set t' : B ⊗[ℂ] V := dualPairEquivC.symm g' with ht' + have hfm : (TensorProduct.map (Φ.restrictScalars ℝ) LinearMap.id) s + = s' + (1 : B) ⊗ₜ[ℝ] cf := by + rw [hs, hs', ← symm_comp_left, + show Φ.restrictScalars ℝ ∘ₗ f = f' + dualPairEquiv ((1 : B) ⊗ₜ[ℝ] cf) from + LinearMap.ext fun ψ => by + simp only [LinearMap.comp_apply, LinearMap.add_apply, hΦdef, + LinearMap.restrictScalars_apply] + rw [hf ψ, dualPairEquiv_one_tmul], + map_add, LinearEquiv.symm_apply_apply] + have hgm : (TensorProduct.map Φ LinearMap.id) t = t' := by + rw [ht, ht', ← symm_comp_left_C, + show Φ ∘ₗ g = g' from LinearMap.ext fun ψ => by + simp only [LinearMap.comp_apply, hΦdef] + rw [hg ψ]] + have hact : dualPairEquivC (tensorAction act s t) = actionFam act f g := by + rw [hs, ht]; rfl + have hact' : dualPairEquivC (tensorAction act s' t') = actionFam act f' g' := by + rw [hs', ht']; rfl + have hπt' : dualPairEquivC t' = g' := by + rw [ht']; exact dualPairEquivC.apply_symm_apply _ + clear_value Φ s t s' t' + have htensor : (TensorProduct.map Φ LinearMap.id) (tensorAction act s t) = + tensorAction act s' t' + + (TensorProduct.map LinearMap.id (act cf)) t' := by + refine (tensorAction_map_left act Φ hΦmul s t).symm.trans + ((congrArg₂ (fun X Y => tensorAction act X Y) hfm hgm).trans ?_) + rw [map_add, LinearMap.add_apply, tensorAction_one_left] + have hread := congrArg (fun z => dualPairEquivC z φ) htensor + simp only [map_add, LinearMap.add_apply, dualPairEquivC_map_left, + dualPairEquivC_map_right] at hread + rw [show Φ (actionFam act f g φ) = + Φ (dualPairEquivC (tensorAction act s t) φ) from by rw [hact], + hread, hact', hπt'] + rfl + +/-- The derived action family `A_ρ · F`: the `s`-derivative of the action of the + gauge field on a matter family, given by the Leibniz convolution of the derivative + symbols over the multiset antidiagonal — the matter analogue of `bracketFamConv`. -/ +noncomputable def actionFamConv + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) (ρ : Fin 1 ⊕ Fin 3) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (s : Multiset (Fin 1 ⊕ Fin 3)) : Module.Dual ℂ V →ₗ[ℂ] B := + (s.antidiagonal.map fun p => actionFam act (A p.1 ρ) (F p.2)).sum + +/-- The covariant derivative `∇_ρ F = [∂_ρ F] + A_ρ · F` of a matter family of + derivative symbols, in the single direction `ρ`: the extra derivative on the symbol + plus the derived action of the gauge field on the value index. With the physicists' + factor of `i` absorbed into `act` (as it is in the gauge-algebra bracket), this is + `∂_ρ F + i A_ρ^a T_a F` in the `D = ∂ + i A` convention. -/ +noncomputable def covDerivAction + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : Module.Dual ℂ V →ₗ[ℂ] B := + F (ρ ::ₘ s) + actionFamConv A act ρ F s + +@[simp] +lemma covDerivAction_apply + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (ρ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V) : + covDerivAction A act F ρ s φ = F (ρ ::ₘ s) φ + actionFamConv A act ρ F s φ := rfl + +/-- **The iterated covariant derivative** `∇_{l 0} ⋯ ∇_{l (n-1)} F` of a matter family + along an ordered tuple of directions: covariant derivatives do not commute (their + commutator is the action of the field strength), so the iteration is order-dependent + and indexed by `(n : ℕ)` and `l : Fin n → (Fin 1 ⊕ Fin 3)` — the same ordered-tuple + indexing as the derivative labels of `IsHiggsAlgebraValued`. The result is again a + family of derivative symbols; the physical iterated covariant derivative is its + value at the empty multiset. -/ +noncomputable def covDerivIter + (A : Multiset (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) + (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) : + (n : ℕ) → (Fin n → (Fin 1 ⊕ Fin 3)) → + Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B + | 0, _ => F + | n + 1, l => covDerivAction A act (covDerivIter A act F n fun i => l i.succ) (l 0) + +@[simp] +lemma covDerivIter_zero (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (l : Fin 0 → (Fin 1 ⊕ Fin 3)) : + covDerivIter A act F 0 l = F := rfl + +@[simp] +lemma covDerivIter_succ (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + {n : ℕ} (l : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) : + covDerivIter A act F (n + 1) l = + covDerivAction A act (covDerivIter A act F n fun i => l i.succ) (l 0) := rfl + +/-! + +## The span lemma + +Replacing derivatives of a matter family by covariant derivatives does not change +the generated algebra of symbols: the correction terms are products of gauge-field +components with matter components. Note the statement is about generated +*subalgebras*, not linear spans — `∇_ρ F − ∂_ρ F` is a sum of products `A · F`, +which lies in the algebra generated by the symbols but not in their linear span. + +-/ + +/-- Decomposition of an assembled adjoint-indexed family along a basis of the gauge + algebra: the components against the dual basis, tensored with the basis vectors. -/ +lemma dualPairEquiv_symm_eq_sum {ι : Type*} [Fintype ι] + (bW : Module.Basis ι ℝ GaugeAlgebra) + (g : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B) : + dualPairEquiv.symm g = ∑ i, g (bW.coord i) ⊗ₜ[ℝ] bW i := by + apply dualPairEquiv.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + symm + rw [map_sum, LinearMap.sum_apply] + simp only [dualPairEquiv_tmul] + have hdual : (∑ i, φ (bW i) • bW.coord i) = φ := by + refine bW.ext fun j => ?_ + rw [LinearMap.sum_apply] + simp only [LinearMap.smul_apply, Module.Basis.coord_apply, Module.Basis.repr_self, + smul_eq_mul] + rw [Finset.sum_eq_single j + (fun i _ hij => by simp [Ne.symm hij]) + (fun h => absurd (Finset.mem_univ j) h)] + simp + calc ∑ i, φ (bW i) • g (bW.coord i) + = g (∑ i, φ (bW i) • bW.coord i) := by rw [map_sum]; simp + _ = g φ := by rw [hdual] + +/-- Decomposition of an assembled matter family along a basis of the value space. -/ +lemma dualPairEquivC_symm_eq_sum {ι : Type*} [Fintype ι] (bW : Module.Basis ι ℂ V) + (g : Module.Dual ℂ V →ₗ[ℂ] B) : + dualPairEquivC.symm g = ∑ i, g (bW.coord i) ⊗ₜ[ℂ] bW i := by + apply dualPairEquivC.injective + rw [LinearEquiv.apply_symm_apply] + refine LinearMap.ext fun φ => ?_ + symm + rw [map_sum, LinearMap.sum_apply] + simp only [dualPairEquivC_tmul] + have hdual : (∑ i, φ (bW i) • bW.coord i) = φ := by + refine bW.ext fun j => ?_ + rw [LinearMap.sum_apply] + simp only [LinearMap.smul_apply, Module.Basis.coord_apply, Module.Basis.repr_self, + smul_eq_mul] + rw [Finset.sum_eq_single j + (fun i _ hij => by simp [Ne.symm hij]) + (fun h => absurd (Finset.mem_univ j) h)] + simp + calc ∑ i, φ (bW i) • g (bW.coord i) + = g (∑ i, φ (bW i) • bW.coord i) := by rw [map_sum]; simp + _ = g φ := by rw [hdual] + +/-- The value of an action of families lies in any subalgebra containing the values + of both families: the action is a finite sum of products of components. -/ +lemma actionFam_apply_mem {act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V} {P : Subalgebra ℂ B} + {f : Module.Dual ℝ GaugeAlgebra →ₗ[ℝ] B} {g : Module.Dual ℂ V →ₗ[ℂ] B} + (hf : ∀ ψ, f ψ ∈ P) (hg : ∀ χ, g χ ∈ P) (φ : Module.Dual ℂ V) : + actionFam act f g φ ∈ P := by + rw [actionFam, dualPairEquiv_symm_eq_sum (Module.finBasis ℝ GaugeAlgebra) f, + dualPairEquivC_symm_eq_sum (Module.finBasis ℂ V) g] + simp only [map_sum, LinearMap.sum_apply, tensorAction_tmul, dualPairEquivC_tmul] + refine sum_mem fun i _ => sum_mem fun j _ => ?_ + exact P.smul_mem (mul_mem (hf _) (hg _)) _ + +/-- **Unitriangularity of the covariant matter tower**: the covariant and plain + derivative symbols of a matter family differ by an element of the subalgebra + generated by the gauge-field symbols and the strictly lower-order matter symbols. + Stated at every derivative multiset `s`, as needed for the induction. -/ +lemma covDerivIter_sub_mem (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V) : + covDerivIter A act F n l s φ - F (List.ofFn l + s) φ ∈ + Algebra.adjoin ℂ + ({b : B | ∃ (u : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A u μ ψ} ∪ + {b : B | ∃ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), + t.card < n + s.card ∧ b = F t χ}) := by + induction n generalizing s φ with + | zero => + simp only [covDerivIter_zero, List.ofFn_zero, + show ((([] : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) = 0) from rfl, + zero_add, sub_self] + exact zero_mem _ + | succ n ih => + have hmono : ∀ {k m : ℕ}, k ≤ m → + Algebra.adjoin ℂ + ({b : B | ∃ u μ ψ, b = A u μ ψ} ∪ + {b : B | ∃ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), + t.card < k ∧ b = F t χ}) ≤ + Algebra.adjoin ℂ + ({b : B | ∃ u μ ψ, b = A u μ ψ} ∪ + {b : B | ∃ (t : Multiset (Fin 1 ⊕ Fin 3)) (χ : Module.Dual ℂ V), + t.card < m ∧ b = F t χ}) := by + intro k m hkm + refine Algebra.adjoin_mono (Set.union_subset_union_right _ ?_) + rintro b ⟨t, χ, ht, rfl⟩ + exact ⟨t, χ, by omega, rfl⟩ + have hms : ((List.ofFn l : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) + s = + ((List.ofFn fun i : Fin n => l i.succ : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3)) + (l 0 ::ₘ s) := by + rw [List.ofFn_succ, + show (((l 0 :: List.ofFn fun i : Fin n => l i.succ : List (Fin 1 ⊕ Fin 3))) : + Multiset (Fin 1 ⊕ Fin 3)) + = l 0 ::ₘ ((List.ofFn fun i : Fin n => l i.succ : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3)) from rfl, + Multiset.cons_add, Multiset.add_cons] + have hsplit : covDerivIter A act F (n + 1) l s φ - + F (List.ofFn l + s) φ = + (covDerivIter A act F n (fun i => l i.succ) (l 0 ::ₘ s) φ - + F (List.ofFn (fun i : Fin n => l i.succ) + (l 0 ::ₘ s)) φ) + + actionFamConv A act (l 0) (covDerivIter A act F n fun i => l i.succ) s φ := by + rw [show covDerivIter A act F (n + 1) l s φ = + covDerivIter A act F n (fun i => l i.succ) (l 0 ::ₘ s) φ + + actionFamConv A act (l 0) + (covDerivIter A act F n fun i => l i.succ) s φ + from rfl, hms] + abel + rw [hsplit] + refine add_mem ?_ ?_ + · refine hmono ?_ (ih (fun i => l i.succ) (l 0 ::ₘ s) φ) + simp only [Multiset.card_cons] + omega + · rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + have hle := Multiset.mem_antidiagonal.mp hp + have h2 : p.2.card ≤ s.card := + hle ▸ Multiset.card_le_card (Multiset.le_add_left _ _) + refine actionFam_apply_mem (fun ψ => ?_) (fun χ => ?_) _ + · exact Algebra.subset_adjoin (Or.inl ⟨p.1, l 0, ψ, rfl⟩) + · have h3 : covDerivIter A act F n (fun i => l i.succ) p.2 χ = + (covDerivIter A act F n (fun i => l i.succ) p.2 χ - + F (List.ofFn (fun i : Fin n => l i.succ) + p.2) χ) + + F (List.ofFn (fun i : Fin n => l i.succ) + p.2) χ := by abel + rw [h3] + refine add_mem (hmono ?_ (ih (fun i => l i.succ) p.2 χ)) ?_ + · omega + · refine Algebra.subset_adjoin + (Or.inr ⟨List.ofFn (fun i : Fin n => l i.succ) + p.2, χ, ?_, rfl⟩) + simp only [Multiset.card_add, Multiset.coe_card, List.length_ofFn] + omega + +/-- Every derivative symbol of the covariant tower is a polynomial in the gauge-field + symbols and the matter symbols. -/ +lemma covDerivIter_mem_adjoin_symbols (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) + (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (s : Multiset (Fin 1 ⊕ Fin 3)) + (φ : Module.Dual ℂ V) : + covDerivIter A act F n l s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + b = F s φ}) := by + induction n generalizing s φ with + | zero => exact Algebra.subset_adjoin (Or.inr ⟨s, φ, rfl⟩) + | succ n ih => + rw [covDerivIter_succ, covDerivAction_apply] + refine add_mem (ih (fun i => l i.succ) (l 0 ::ₘ s) φ) ?_ + rw [actionFamConv, Multiset.sum_linearMap_apply, Multiset.map_map] + refine multiset_sum_mem _ fun x hx => ?_ + obtain ⟨p, hp, rfl⟩ := Multiset.mem_map.mp hx + refine actionFam_apply_mem (fun ψ' => ?_) (fun χ => ?_) _ + · exact Algebra.subset_adjoin (Or.inl ⟨p.1, l 0, ψ', rfl⟩) + · exact ih (fun i => l i.succ) p.2 χ + +/-- **The span lemma**: the algebra of symbols generated by the gauge field together + with a matter family's *derivative* symbols equals the one generated by the gauge + field together with the matter family's *covariant* derivative tower. The + correction `∇_ρ − ∂_ρ` is the derived action of the gauge field — a sum of products + of symbols, absorbed by the algebra structure. -/ +theorem adjoin_symbols_eq_adjoin_covDerivIter (act : GaugeAlgebra →ₗ[ℝ] V →ₗ[ℂ] V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual ℂ V →ₗ[ℂ] B) : + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + b = F s φ}) = + Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + b = covDerivIter A act F n l 0 φ}) := by + refine le_antisymm (Algebra.adjoin_le ?_) (Algebra.adjoin_le ?_) + · rintro x (⟨s, μ, ψ, rfl⟩ | ⟨s, φ, rfl⟩) + · exact Algebra.subset_adjoin (Or.inl ⟨s, μ, ψ, rfl⟩) + · -- express a matter symbol through the covariant tower, by strong induction on + -- the order + have main : ∀ n, ∀ (s : Multiset (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + s.card ≤ n → + F s φ ∈ Algebra.adjoin ℂ + ({b : B | ∃ (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) + (ψ : Module.Dual ℝ GaugeAlgebra), b = A s μ ψ} ∪ + {b : B | ∃ (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual ℂ V), + b = covDerivIter A act F n l 0 φ}) := by + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro s φ hs + set L := s.toList with hL' + have hL : Multiset.ofList L = s := Multiset.coe_toList _ + have hofFn : List.ofFn L.get = L := List.ofFn_get L + rw [show F s φ = covDerivIter A act F L.length L.get 0 φ - + (covDerivIter A act F L.length L.get 0 φ - + F (List.ofFn L.get + 0) φ) from by + rw [add_zero, hofFn, hL]; abel] + refine sub_mem (Algebra.subset_adjoin (Or.inr ⟨L.length, L.get, φ, rfl⟩)) ?_ + refine SetLike.le_def.mp (Algebra.adjoin_le ?_) + (covDerivIter_sub_mem act F L.length L.get 0 φ) + rintro b (⟨u, μ, ψ, rfl⟩ | ⟨t, χ, htc, rfl⟩) + · exact Algebra.subset_adjoin (Or.inl ⟨u, μ, ψ, rfl⟩) + · have htn : t.card < n := by + have hlen : L.length = s.card := Multiset.length_toList s + simp only [Multiset.card_zero] at htc + omega + exact ih t.card htn t χ (le_refl _) + exact main s.card s φ (le_refl _) + · rintro x (⟨s, μ, ψ, rfl⟩ | ⟨n, l, φ, rfl⟩) + · exact Algebra.subset_adjoin (Or.inl ⟨s, μ, ψ, rfl⟩) + · exact covDerivIter_mem_adjoin_symbols act F n l 0 φ + +end Action + + +end IsGaugeField + +end StandardModel diff --git a/Physlib/Relativity/DerivAlgebra.lean b/Physlib/Relativity/DerivAlgebra.lean new file mode 100644 index 000000000..f43ca120b --- /dev/null +++ b/Physlib/Relativity/DerivAlgebra.lean @@ -0,0 +1,654 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Mathlib.RingTheory.TensorProduct.Basic +public import Physlib.Relativity.Tensors.ComplexTensor.Basic +public import Physlib.Mathematics.ConjModule +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basis +public import Mathlib.Algebra.TrivSqZeroExt.Basic +public import Mathlib.Data.Finsupp.Multiset +public import Mathlib.Data.Finsupp.Weight +public import Physlib.Particles.StandardModel.Basic +public import Mathlib.RingTheory.MvPowerSeries.Basic +public import Mathlib.LinearAlgebra.Matrix.Determinant.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basis +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Relativity.JetRing.Matrix +public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic +public import Physlib.Relativity.Tensors.RealTensor.CoVector.Representation +/-! +# Derivative algebras + +-/ + +@[expose] public section + +/-! + +## B. The complex derivative algebra + +-/ + +abbrev DerivAlgebraComplex := SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule) + +namespace DerivAlgebraComplex + +/-! + +### B.1. The basis indexed by multisets + +-/ + +/-- The basis of the algebra of derivative symbols, indexed by multisets of + spacetime indices: the multiset `s` labels the monomial `∂_s`. -/ +noncomputable def basis : + Module.Basis (Multiset (Fin 1 ⊕ Fin 3)) ℂ DerivAlgebraComplex := + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.reindex Multiset.toFinsupp.toEquiv.symm + +/-- The basis vector at a multiset of derivative indices is the corresponding + basis monomial of the symmetric algebra of dual symbols. -/ +lemma basis_apply (s : Multiset (Fin 1 ⊕ Fin 3)) : + basis s = + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (Multiset.toFinsupp s) := by + rw [basis, Module.Basis.reindex_apply, Equiv.symm_symm] + rfl + +/-- The basis vector at the empty multiset is the unit of the algebra: the + zeroth-order symbol carries no derivatives. -/ +lemma basis_nil : + basis ({} : Multiset (Fin 1 ⊕ Fin 3)) = 1 := by + have h : (MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℂ) ((0 : (Fin 1 ⊕ Fin 3) →₀ ℕ)) = 1 := by + rw [MvPolynomial.coe_basisMonomials] + simp [MvPolynomial.monomial_zero'] + rw [basis, Module.Basis.reindex_apply, Equiv.symm_symm, + show Multiset.toFinsupp.toEquiv ({} : Multiset (Fin 1 ⊕ Fin 3)) = 0 by simp, + Module.Basis.symmetricAlgebra, Module.Basis.map_apply, h] + simp + +/-- The basis vector at a singleton multiset is the corresponding first-order + derivative symbol. -/ +lemma basis_singleton (μ : Fin 1 ⊕ Fin 3) : + basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = + SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) := by + have h : (MvPolynomial.basisMonomials (Fin 1 ⊕ Fin 3) ℂ) (Finsupp.single μ 1) = + MvPolynomial.X μ := rfl + rw [basis, Module.Basis.reindex_apply, Equiv.symm_symm, + show Multiset.toFinsupp.toEquiv ({μ} : Multiset (Fin 1 ⊕ Fin 3)) = + Finsupp.single μ 1 by simp, + Module.Basis.symmetricAlgebra, Module.Basis.map_apply, h] + simp + +/-- Basis monomials multiply by adding the multisets of derivative indices: + `∂_s ∂_t = ∂_{s + t}`. -/ +lemma basis_mul (s t : Multiset (Fin 1 ⊕ Fin 3)) : + basis s * basis t = basis (s + t) := by + rw [basis_apply, basis_apply, basis_apply, map_add] + simp only [Module.Basis.symmetricAlgebra, Module.Basis.map_apply, + show ∀ p, (SymmetricAlgebra.equivMvPolynomial + Lorentz.complexCoBasis.dualBasis).symm.toLinearEquiv p = + (SymmetricAlgebra.equivMvPolynomial Lorentz.complexCoBasis.dualBasis).symm p + from fun _ => rfl, + ← map_mul, MvPolynomial.coe_basisMonomials] + simp only [MvPolynomial.monomial_mul, mul_one] + +/-! + +### B.2. The derivative operator + +-/ + +/-- The derivative of an element in `DerivAlgebraComplex` taking e.g. + `∂_s` to `∂_μ ∂_s`. -/ +noncomputable def deriv (μ : Fin 1 ⊕ Fin 3) : DerivAlgebraComplex →ₗ[ℂ] DerivAlgebraComplex := + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.constr ℂ fun m => + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (m + Finsupp.single μ 1) + +lemma deriv_basis (μ : Fin 1 ⊕ Fin 3) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + deriv μ (Lorentz.complexCoBasis.dualBasis.symmetricAlgebra m) = + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (m + Finsupp.single μ 1) := by + rw [deriv, Module.Basis.constr_basis] + +lemma deriv_comm_apply (μ ν : Fin 1 ⊕ Fin 3) (x : DerivAlgebraComplex) : + deriv μ (deriv ν x) = deriv ν (deriv μ x) := by + have h : (deriv μ) ∘ₗ (deriv ν) = (deriv ν) ∘ₗ (deriv μ) := by + refine Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.ext fun m => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, deriv_basis] + rw [add_assoc, add_assoc, add_comm (Finsupp.single ν 1)] + exact LinearMap.congr_fun h x + +/-- The derivative operator on the multiset basis: appending the derivative + index to the multiset. -/ +lemma deriv_basis_multiset (μ : Fin 1 ⊕ Fin 3) (s : Multiset (Fin 1 ⊕ Fin 3)) : + deriv μ (basis s) = basis (s + {μ}) := by + rw [basis_apply, deriv_basis, basis_apply, + show Multiset.toFinsupp (s + {μ}) = Multiset.toFinsupp s + Finsupp.single μ 1 from by + rw [map_add, Multiset.toFinsupp_singleton]] + +/-- The derivative operator is right multiplication by the first-order derivative + symbol. -/ +lemma deriv_apply_eq_mul (μ : Fin 1 ⊕ Fin 3) (a : DerivAlgebraComplex) : + deriv μ a = a * basis ({μ} : Multiset (Fin 1 ⊕ Fin 3)) := by + have h : deriv μ = LinearMap.mulRight ℂ (basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) := by + refine basis.ext fun s => ?_ + rw [deriv_basis_multiset, LinearMap.mulRight_apply, basis_mul] + rw [LinearMap.congr_fun h a, LinearMap.mulRight_apply] + +/-! + +### B.2. Evaluating on the Jet ring + +-/ +open Nat + +/-- The evaluation map taking a function `f : JetRing` to `∂_μ f`. -/ +noncomputable def eval : DerivAlgebraComplex →ₗ[ℂ] JetRing →ₗ[ℂ] ℂ := + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.constr ℂ fun m => + (∏ μ, (m μ)! : ℕ) • MvPowerSeries.coeff m + + +@[simp] +lemma eval_basis (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) (f : JetRing) : + eval (Lorentz.complexCoBasis.dualBasis.symmetricAlgebra m) f = + (∏ μ, (m μ)! : ℕ) • MvPowerSeries.coeff m f := by + rw [eval, Module.Basis.constr_basis] + rfl + +lemma eval_monomial (p : DerivAlgebraComplex) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + eval p (MvPowerSeries.monomial m 1) = + ((∏ μ, (m μ)! : ℕ) : ℂ) * Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.repr p m := by + classical + rw [eval, Module.Basis.constr_apply, Finsupp.sum, LinearMap.sum_apply] + simp only [LinearMap.smul_apply, MvPowerSeries.coeff_monomial] + rw [Finset.sum_eq_single m] + · by_cases hm : m ∈ (Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.repr p).support + · simp [mul_comm] + · rw [Finsupp.notMem_support_iff.mp hm] + simp + · intro i _ hi + simp [hi] + · intro hm + rw [Finsupp.notMem_support_iff.mp hm] + simp + +lemma eval_injective {p q : DerivAlgebraComplex} + (h : ∀ f, eval p f = eval q f) : p = q := by + refine Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.ext_elem fun m => ?_ + have hf := h (MvPowerSeries.monomial m 1) + rw [eval_monomial, eval_monomial] at hf + have hfac : ((∏ μ, (m μ)! : ℕ) : ℂ) ≠ 0 := by + rw [Nat.cast_ne_zero] + exact Finset.prod_ne_zero_iff.mpr fun μ _ => Nat.factorial_ne_zero (m μ) + exact mul_left_cancel₀ hfac hf + +/-- Adjointness: the shift of derivative symbols is the transpose of the formal + partial derivative under the divided-power pairing. -/ +lemma eval_deriv (ν : Fin 1 ⊕ Fin 3) (p : DerivAlgebraComplex) (f : JetRing) : + eval (deriv ν p) f = eval p (MvPowerSeries.pderiv ℂ ν f) := by + have h : (eval.flip f) ∘ₗ deriv ν = + eval.flip (MvPowerSeries.pderiv ℂ ν f) := by + refine Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.ext fun m => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply, + deriv_basis, eval_basis, MvPowerSeries.coeff_pderiv] + have hfac : (∏ ρ, (((m + Finsupp.single ν 1) : (Fin 1 ⊕ Fin 3) →₀ ℕ) ρ)!) = + (m ν + 1) * ∏ ρ, (m ρ)! := by + rw [show (∏ ρ : Fin 1 ⊕ Fin 3, + (((m + Finsupp.single ν 1) : (Fin 1 ⊕ Fin 3) →₀ ℕ) ρ)!) = + ∏ ρ, ((if ρ = ν then m ν + 1 else 1) * (m ρ)!) from + Finset.prod_congr rfl fun ρ _ => by + rcases eq_or_ne ρ ν with rfl | h + · rw [Finsupp.add_apply, Finsupp.single_eq_same, Nat.factorial_succ, if_pos rfl] + · rw [Finsupp.add_apply, Finsupp.single_eq_of_ne h, add_zero, if_neg h, one_mul], + Finset.prod_mul_distrib, Finset.prod_ite_eq' Finset.univ ν] + simp + rw [nsmul_eq_mul, nsmul_eq_mul, hfac] + push_cast + ring + exact LinearMap.congr_fun h p + +/-! + +### B.2. The action of the Jet ring + +-/ + +/-- The action of `χ` on the derivatives, this takes `∂_μ ·` to `∂_μ (χ ·)`, + expanded out explicitly. -/ +noncomputable def jetRingAction (χ : JetRing) : DerivAlgebraComplex →ₗ[ℂ] DerivAlgebraComplex := + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.constr ℂ fun m => + ∑ p ∈ Finset.antidiagonal m, + ((∏ μ, (m μ).descFactorial (p.1 μ) : ℕ) : ℂ) • MvPowerSeries.coeff p.1 χ • + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra p.2 + +lemma jetRingAction_basis (χ : JetRing) (m : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + jetRingAction χ (Lorentz.complexCoBasis.dualBasis.symmetricAlgebra m) = + ∑ p ∈ Finset.antidiagonal m, + ((∏ μ, (m μ).descFactorial (p.1 μ) : ℕ) : ℂ) • MvPowerSeries.coeff p.1 χ • + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra p.2 := by + rw [jetRingAction, Module.Basis.constr_basis] + +lemma eval_jetRingAction (χ f : JetRing) (p : DerivAlgebraComplex) : + eval (jetRingAction χ p) f = eval p (χ * f) := by + classical + have h : (eval.flip f) ∘ₗ jetRingAction χ = eval.flip (χ * f) := by + refine Lorentz.complexCoBasis.dualBasis.symmetricAlgebra.ext fun m => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply, LinearMap.flip_apply] + rw [jetRingAction, Module.Basis.constr_basis] + simp only [map_sum, map_smul, LinearMap.sum_apply, LinearMap.smul_apply, + eval_basis, smul_eq_mul, nsmul_eq_mul] + rw [MvPowerSeries.coeff_mul, Finset.mul_sum] + refine Finset.sum_congr rfl fun q hq => ?_ + have hm : q.1 + q.2 = m := Finset.mem_antidiagonal.mp hq + have hfac : ((∏ μ, (m μ).descFactorial (q.1 μ) : ℕ) : ℂ) * + ((∏ μ, (q.2 μ)! : ℕ) : ℂ) = ((∏ μ, (m μ)! : ℕ) : ℂ) := by + rw [← Nat.cast_mul, ← Finset.prod_mul_distrib] + congr 1 + refine Finset.prod_congr rfl fun μ _ => ?_ + rw [mul_comm] + have h1 : q.1 μ ≤ m μ := by + rw [← hm]; simp + have h2 : m μ - q.1 μ = q.2 μ := by + rw [← hm]; simp + rw [← h2] + exact Nat.factorial_mul_descFactorial h1 + rw [← hfac] + ring + exact LinearMap.congr_fun h p + +/-- Constant jets act on the derivative symbols by their value: `C c` has no + derivative coordinates. -/ +@[simp] +lemma jetRingAction_C (c : ℂ) : + jetRingAction (MvPowerSeries.C c) = c • LinearMap.id := by + refine LinearMap.ext fun p => eval_injective fun f => ?_ + rw [eval_jetRingAction, + show (MvPowerSeries.C c : JetRing) * f = c • f from + (algebraMap_smul JetRing c f).symm ▸ (Algebra.smul_def c f).symm] + simp + +@[simp] +lemma jetRingAction_one : jetRingAction (1 : JetRing) = LinearMap.id := by + rw [show (1 : JetRing) = MvPowerSeries.C 1 from (map_one _).symm, jetRingAction_C, one_smul] + +/-- The derivative action is multiplicative: it is the transpose of multiplication + in the commutative jet ring. This makes `χ ↦ χ(∂)` a monoid homomorphism and + hence yields representations of the jet gauge group on polynomial jet spaces. -/ +lemma jetRingAction_mul (χ ψ : JetRing) : + jetRingAction (χ * ψ) = jetRingAction χ ∘ₗ jetRingAction ψ := by + refine LinearMap.ext fun p => eval_injective fun f => ?_ + simp only [LinearMap.coe_comp, Function.comp_apply] + rw [eval_jetRingAction, eval_jetRingAction, eval_jetRingAction] + ring_nf + + +@[simp] +lemma jetRingAction_zero : jetRingAction (0 : JetRing) = 0 := by + simp only [jetRingAction, Fintype.prod_sum_type, Finset.univ_unique, Fin.default_eq_zero, + Fin.isValue, Finset.prod_singleton, Nat.cast_mul, Nat.cast_prod, MvPowerSeries.coeff_zero, + zero_smul, smul_zero, Finset.sum_const_zero, EmbeddingLike.map_eq_zero_iff] + rfl + +lemma jetRingAction_add (χ ψ : JetRing) : + jetRingAction (χ + ψ) = jetRingAction χ + jetRingAction ψ := by + refine LinearMap.ext fun p => eval_injective fun f => ?_ + simp only [LinearMap.add_apply, map_add, eval_jetRingAction] + rw [add_mul, map_add] + +/-- The derivative action as a ring homomorphism from the jet ring to the + endomorphisms of the algebra of derivative symbols: the module structure of the + jet ring on its graded dual. -/ +noncomputable def jetRingActionHom : JetRing →+* Module.End ℂ DerivAlgebraComplex where + toFun := jetRingAction + map_one' := jetRingAction_one + map_mul' χ ψ := jetRingAction_mul χ ψ + map_zero' := jetRingAction_zero + map_add' := jetRingAction_add + +/-- The actions of two jets commute: the jet ring is commutative. -/ +lemma jetRingAction_comm (χ ψ : JetRing) (a : DerivAlgebraComplex) : + jetRingAction χ (jetRingAction ψ a) = jetRingAction ψ (jetRingAction χ a) := by + rw [← LinearMap.comp_apply, ← jetRingAction_mul, mul_comm, jetRingAction_mul, + LinearMap.comp_apply] + +/-- The derivative action on the zeroth-order (field) symbol: it is scaled by the + value of the jet at the base point. -/ +@[simp] +lemma jetRingAction_apply_one (χ : JetRing) : + jetRingAction χ (1 : DerivAlgebraComplex) = + MvPowerSeries.constantCoeff χ • 1 := by + have h0 : Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + 1 := by + rw [show (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + Multiset.toFinsupp ({} : Multiset (Fin 1 ⊕ Fin 3)) by simp, + ← basis_apply, basis_nil] + rw [show (1 : DerivAlgebraComplex) = + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra 0 from h0.symm, + jetRingAction, Module.Basis.constr_basis, Finsupp.antidiagonal_zero, Finset.sum_singleton] + simp + +/-- The derivative action on a first-order derivative symbol implements the Leibniz + rule: `∂_μ ↦ χ(0) ∂_μ + (∂_μχ)(0) 1`. The value of the jet multiplies the + first-derivative symbol, and its first derivative feeds the zeroth-order + symbol. -/ +lemma jetRingAction_apply_ι (χ : JetRing) (μ : Fin 1 ⊕ Fin 3) : + jetRingAction χ (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ)) = + MvPowerSeries.constantCoeff χ • + SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) + + MvPowerSeries.coeff (Finsupp.single μ 1) χ • 1 := by + classical + have h0 : Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + 1 := by + rw [show (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + Multiset.toFinsupp ({} : Multiset (Fin 1 ⊕ Fin 3)) by simp, + ← basis_apply, basis_nil] + have hs : Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (Finsupp.single μ 1) = + SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) := by + rw [show (Finsupp.single μ 1 : (Fin 1 ⊕ Fin 3) →₀ ℕ) = + Multiset.toFinsupp ({μ} : Multiset (Fin 1 ⊕ Fin 3)) by simp, + ← basis_apply, basis_singleton] + rw [show SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.complexCoBasis.dualBasis μ) = + Lorentz.complexCoBasis.dualBasis.symmetricAlgebra (Finsupp.single μ 1) from hs.symm, + jetRingAction, Module.Basis.constr_basis, Finsupp.antidiagonal_single, + show Finset.antidiagonal (1 : ℕ) = {(0, 1), (1, 0)} by decide, Finset.map_insert, + Finset.map_singleton, Finset.sum_insert (by simp [Finsupp.single_eq_zero]), + Finset.sum_singleton] + have h1 : (∏ ν, ((Finsupp.single μ 1) ν).descFactorial ((Finsupp.single μ 1) ν)) = 1 := + Finset.prod_eq_one fun ν _ => by + rcases eq_or_ne μ ν with h | h + · subst h; simp + · simp [h] + simp only [Function.Embedding.coe_prodMap, Function.Embedding.coeFn_mk, Prod.map_apply, + Finsupp.single_zero, Finsupp.coe_zero, Pi.zero_apply, Nat.descFactorial_zero, + Finset.prod_const_one, Nat.cast_one, one_smul, MvPowerSeries.coeff_zero_eq_constantCoeff, + h1, hs, h0] + +/-- The commutation of the jet-ring action with the derivative operator: acting by + `χ` after differentiating equals differentiating after acting, plus the action + of the derivative `∂_ν χ`. This is the operator form of the Leibniz rule + `∂_ν (χ f) = χ ∂_ν f + (∂_ν χ) f` under the divided-power pairing. -/ +lemma jetRingAction_deriv (χ : JetRing) (ν : Fin 1 ⊕ Fin 3) (a : DerivAlgebraComplex) : + jetRingAction χ (deriv ν a) = + deriv ν (jetRingAction χ a) + jetRingAction (MvPowerSeries.pderiv ℂ ν χ) a := by + refine eval_injective fun f => ?_ + rw [eval_jetRingAction, eval_deriv, Derivation.leibniz, smul_eq_mul, smul_eq_mul, + map_add, map_add, LinearMap.add_apply, eval_deriv, eval_jetRingAction, + eval_jetRingAction, mul_comm f] + +/-! + +### B.5. The action of the Lorentz group + +-/ + +/-- The components of a dual representation on a dual basis: if `ρ g⁻¹` has + matrix `M` in the basis `b` (columns indexing the argument), then `ρ.dual g` + acts on the dual basis by the rows of `M`. -/ +lemma _root_.Representation.dual_apply_dualBasis {k G V ι : Type*} [CommRing k] + [Group G] [AddCommGroup V] [Module k V] [Fintype ι] [DecidableEq ι] + (ρ : Representation k G V) (b : Module.Basis ι k V) (g : G) (i : ι) + (M : Matrix ι ι k) (hM : ∀ j, ρ g⁻¹ (b j) = ∑ l, M l j • b l) : + ρ.dual g (b.dualBasis i) = ∑ j, M i j • b.dualBasis j := by + refine b.ext fun j => ?_ + rw [Representation.dual_apply, Module.Dual.transpose_apply, LinearMap.comp_apply, hM] + simp [Finsupp.single_apply, Finset.sum_ite_eq, Finset.sum_ite_eq'] + +open Matrix MatrixGroups + +/-- The representation of the Lorentz group `SL(2,ℂ)` on the algebra of derivative + symbols, extending the dual covector representation multiplicatively. -/ +noncomputable def repLorentzGroup : Representation ℂ SL(2,ℂ) DerivAlgebraComplex where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual Λ)).toLinearMap + map_one' := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual 1) = + AlgHom.id ℂ (SymmetricAlgebra ℂ (Module.Dual ℂ Lorentz.CoℂModule)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + rfl + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : repLorentzGroup Λ 1 = 1:= by + simp [repLorentzGroup] + +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) (a b : DerivAlgebraComplex) : + repLorentzGroup Λ (a * b) = repLorentzGroup Λ a * repLorentzGroup Λ b := by + simp [repLorentzGroup, map_mul] + +/-- The Lorentz action on a generator. -/ +@[simp] +lemma repLorentzGroup_apply_ι (Λ : SL(2,ℂ)) (x : Module.Dual ℂ Lorentz.CoℂModule) : + repLorentzGroup Λ (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) x) = + SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) + (Lorentz.CoℂModule.SL2CRep.dual Λ x) := by + simp [repLorentzGroup] + +/-- The Lorentz action on a derivative: the derivative symbol transforms as a + covector, mixing the spacetime directions by the components of `Λ` in the dual + covector representation. -/ +lemma repLorentzGroup_deriv (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) (a : DerivAlgebraComplex) : + repLorentzGroup Λ (deriv μ a) = + ∑ ν, (Lorentz.CoℂModule.SL2CRep.dual Λ (Lorentz.complexCoBasis.dualBasis μ)) + (Lorentz.complexCoBasis ν) • deriv ν (repLorentzGroup Λ a) := by + have hb : repLorentzGroup Λ (basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ ν, (Lorentz.CoℂModule.SL2CRep.dual Λ (Lorentz.complexCoBasis.dualBasis μ)) + (Lorentz.complexCoBasis ν) • basis ({ν} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [basis_singleton, repLorentzGroup_apply_ι] + conv_lhs => rw [← Lorentz.complexCoBasis.dualBasis.sum_repr + (Lorentz.CoℂModule.SL2CRep.dual Λ (Lorentz.complexCoBasis.dualBasis μ))] + rw [map_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_smul, Module.Basis.dualBasis_repr, basis_singleton] + rw [deriv_apply_eq_mul, repLorentzGroup_apply_mul, hb, Finset.mul_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [mul_smul_comm, ← deriv_apply_eq_mul] + +/-- The components of the complex dual covector action on the dual basis: the + dual derivative slots transform contravariantly, by the columns of the + (complexified) Lorentz matrix. The complex analogue of + `Lorentz.CoVector.sl2Rep_dual_dualBasis`. -/ +lemma _root_.Lorentz.CoℂModule.SL2CRep_dual_dualBasis (Λ : SL(2,ℂ)) + (μ : Fin 1 ⊕ Fin 3) : + Lorentz.CoℂModule.SL2CRep.dual Λ (Lorentz.complexCoBasis.dualBasis μ) = + ∑ j, (((Lorentz.SL2C.toLorentzGroup Λ).1 j μ : ℝ) : ℂ) • + Lorentz.complexCoBasis.dualBasis j := by + refine Representation.dual_apply_dualBasis _ _ _ _ + (Matrix.of fun l j => (((Lorentz.SL2C.toLorentzGroup Λ).1 j l : ℝ) : ℂ)) + (fun j => ?_) + have hexp : Lorentz.CoℂModule.SL2CRep Λ⁻¹ (Lorentz.complexCoBasis j) = + ∑ l, (LinearMap.toMatrix Lorentz.complexCoBasis Lorentz.complexCoBasis + (Lorentz.CoℂModule.SL2CRep Λ⁻¹)) l j • Lorentz.complexCoBasis l := by + conv_lhs => rw [← Lorentz.complexCoBasis.sum_repr + (Lorentz.CoℂModule.SL2CRep Λ⁻¹ (Lorentz.complexCoBasis j))] + refine Finset.sum_congr rfl fun l _ => ?_ + rw [LinearMap.toMatrix_apply] + rw [hexp] + refine Finset.sum_congr rfl fun l _ => ?_ + congr 1 + rw [Lorentz.complexCoBasis_ρ_apply, map_inv, Matrix.transpose_apply, + ← LorentzGroup.toComplex_inv, Matrix.inv_inv_of_invertible] + rfl + +/-- The Lorentz action on the singleton derivative monomial: the derivative + slot transforms by the columns of the Lorentz matrix. -/ +lemma repLorentzGroup_basis_singleton (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + repLorentzGroup Λ (basis ({μ} : Multiset (Fin 1 ⊕ Fin 3))) = + ∑ ν, (((Lorentz.SL2C.toLorentzGroup Λ).1 ν μ : ℝ) : ℂ) • + basis ({ν} : Multiset (Fin 1 ⊕ Fin 3)) := by + rw [basis_singleton, repLorentzGroup_apply_ι, + Lorentz.CoℂModule.SL2CRep_dual_dualBasis, map_sum] + refine Finset.sum_congr rfl fun ν _ => ?_ + rw [map_smul, basis_singleton] + +/-! + +### B.6. The derivative-degree scaling + +-/ + +/-- The derivative-degree scaling on the algebra of derivative symbols: the + algebra map multiplying each generator by `t`, hence each degree-`n` monomial + by `t ^ n`. -/ +noncomputable def gradeScale (t : ℂ) : DerivAlgebraComplex →ₐ[ℂ] DerivAlgebraComplex := + SymmetricAlgebra.lift (t • SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule)) + +@[simp] +lemma gradeScale_ι (t : ℂ) (x : Module.Dual ℂ Lorentz.CoℂModule) : + gradeScale t (SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) x) = + t • SymmetricAlgebra.ι ℂ (Module.Dual ℂ Lorentz.CoℂModule) x := by + rw [gradeScale, SymmetricAlgebra.lift_ι_apply] + rfl + +/-- The degree scaling multiplies the basis monomial at `s` by `t ^ |s|`. -/ +lemma gradeScale_basis (t : ℂ) (s : Multiset (Fin 1 ⊕ Fin 3)) : + gradeScale t (basis s) = t ^ s.card • basis s := by + induction s using Multiset.induction_on with + | empty => + rw [show basis (0 : Multiset (Fin 1 ⊕ Fin 3)) = 1 from basis_nil, map_one] + simp + | cons a s ih => + rw [← Multiset.singleton_add, ← basis_mul, map_mul, ih, basis_singleton, + gradeScale_ι, smul_mul_smul_comm, ← _root_.pow_succ', ← basis_singleton, + basis_mul, Multiset.singleton_add, Multiset.card_cons] + +/-- The degree scaling commutes with the Lorentz action: the Lorentz action + preserves the derivative degree. -/ +lemma gradeScale_repLorentzGroup (t : ℂ) (Λ : SL(2,ℂ)) (a : DerivAlgebraComplex) : + gradeScale t (repLorentzGroup Λ a) = repLorentzGroup Λ (gradeScale t a) := by + have h : (gradeScale t).comp (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual Λ)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℂ _ ∘ₗ Lorentz.CoℂModule.SL2CRep.dual Λ)).comp + (gradeScale t) := by + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + exact DFunLike.congr_fun h a + +end DerivAlgebraComplex + + +/-! + +## C. The real derivative algebra + +-/ + +abbrev DerivAlgebraReal := SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector) + +namespace DerivAlgebraReal +open Matrix MatrixGroups + +/-- The representation of the Lorentz group on the real Lorentz-covector derivative + slots, obtained from the real Lorentz-vector representation through the covering + map `SL(2,ℂ) →* LorentzGroup 3`. -/ +noncomputable def _root_.Lorentz.CoVector.sl2Rep : Representation ℝ SL(2,ℂ) Lorentz.CoVector := + MonoidHom.comp Lorentz.CoVector.rep Lorentz.SL2C.toLorentzGroup + + +/-- The representation of the Lorentz group `SL(2,ℂ)` on the algebra of derivative + symbols, extending the dual covector representation multiplicatively. -/ +noncomputable def repLorentzGroup : Representation ℝ SL(2,ℂ) DerivAlgebraReal where + toFun Λ := (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual Λ)).toLinearMap + map_one' := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual 1) = + AlgHom.id ℝ (SymmetricAlgebra ℝ (Module.Dual ℝ Lorentz.CoVector)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + rfl + map_mul' Λ1 Λ2 := by + suffices h : SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual (Λ1 * Λ2)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual Λ1)).comp + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual Λ2)) by + rw [h]; rfl + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp [map_mul, Module.End.mul_apply] + +/-- The Lorentz action on a generator of the real derivative algebra. -/ +@[simp] +lemma repLorentzGroup_apply_ι (Λ : SL(2,ℂ)) (x : Module.Dual ℝ Lorentz.CoVector) : + repLorentzGroup Λ (SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) x) = + SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) + (Lorentz.CoVector.sl2Rep.dual Λ x) := by + simp [repLorentzGroup] + +/-- The real derivative-algebra representation is multiplicative: it is the lift of a linear + map to the symmetric algebra. -/ +lemma repLorentzGroup_apply_mul (Λ : SL(2,ℂ)) + (a b : DerivAlgebraReal) : + DerivAlgebraReal.repLorentzGroup Λ (a * b) = + DerivAlgebraReal.repLorentzGroup Λ a * DerivAlgebraReal.repLorentzGroup Λ b := by + simp [DerivAlgebraReal.repLorentzGroup] + +@[simp] +lemma repLorentzGroup_apply_one (Λ : SL(2,ℂ)) : + DerivAlgebraReal.repLorentzGroup Λ 1 = 1 := by + simp [DerivAlgebraReal.repLorentzGroup] + +/-- The components of the dual covector action on the dual basis: the dual + derivative slots transform contravariantly, by the columns of the Lorentz + matrix. -/ +lemma _root_.Lorentz.CoVector.sl2Rep_dual_dualBasis (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3) : + Lorentz.CoVector.sl2Rep.dual Λ (Lorentz.CoVector.basis.dualBasis μ) = + ∑ j, (Lorentz.SL2C.toLorentzGroup Λ).1 j μ • + Lorentz.CoVector.basis.dualBasis j := by + refine Representation.dual_apply_dualBasis _ _ _ _ + (Matrix.of fun l j => (Lorentz.SL2C.toLorentzGroup Λ).1 j l) (fun j => ?_) + rw [show Lorentz.CoVector.sl2Rep Λ⁻¹ = + Lorentz.CoVector.rep (Lorentz.SL2C.toLorentzGroup Λ⁻¹) from rfl, + Lorentz.CoVector.rep_apply_basis, ← LorentzGroup.coe_inv, map_inv, inv_inv] + rfl + +/-- The derivative-degree scaling on the real algebra of derivative symbols: + the algebra map multiplying each generator by `t`. -/ +noncomputable def gradeScale (t : ℝ) : DerivAlgebraReal →ₐ[ℝ] DerivAlgebraReal := + SymmetricAlgebra.lift (t • SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector)) + +@[simp] +lemma gradeScale_ι (t : ℝ) (x : Module.Dual ℝ Lorentz.CoVector) : + gradeScale t (SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) x) = + t • SymmetricAlgebra.ι ℝ (Module.Dual ℝ Lorentz.CoVector) x := by + rw [gradeScale, SymmetricAlgebra.lift_ι_apply] + rfl + +/-- The degree scaling commutes with the Lorentz action on the real derivative + symbols. -/ +lemma gradeScale_repLorentzGroup (t : ℝ) (Λ : SL(2,ℂ)) (a : DerivAlgebraReal) : + gradeScale t (repLorentzGroup Λ a) = repLorentzGroup Λ (gradeScale t a) := by + have h : (gradeScale t).comp (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual Λ)) = + (SymmetricAlgebra.lift + (SymmetricAlgebra.ι ℝ _ ∘ₗ Lorentz.CoVector.sl2Rep.dual Λ)).comp + (gradeScale t) := by + refine SymmetricAlgebra.algHom_ext (LinearMap.ext fun x => ?_) + simp + exact DFunLike.congr_fun h a + +end DerivAlgebraReal diff --git a/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean b/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean index 6884f71db..96025fd99 100644 --- a/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean +++ b/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean @@ -32,6 +32,8 @@ Although a different index convention is used there. namespace Fermion noncomputable section +TODO "Relate `DualLeftHandedWeyl` to `LeftHandedWeyl` via `Module.dual`." + /-- The module in which dual-left handed fermions live. This is equivalent to `Fin 2 → ℂ`. -/ structure DualLeftHandedWeyl where /-- The underlying value in `Fin 2 → ℂ`. -/ diff --git a/Physlib/Relativity/Fermions/Weyl/Metric.lean b/Physlib/Relativity/Fermions/Weyl/Metric.lean index 6e6ae5df8..cf6b3ea46 100644 --- a/Physlib/Relativity/Fermions/Weyl/Metric.lean +++ b/Physlib/Relativity/Fermions/Weyl/Metric.lean @@ -118,6 +118,13 @@ lemma leftMetric_apply_one : leftMetric (1 : ℂ) = leftMetricVal := by change (1 : ℂ) • leftMetricVal = leftMetricVal simp only [one_smul] +/-- The metric `εᵃᵃ` is invariant under the action of `SL(2,ℂ)`. -/ +lemma leftMetricVal_rep (M : SL(2,ℂ)) : + TensorProduct.map (LeftHandedWeyl.rep M) (LeftHandedWeyl.rep M) leftMetricVal = + leftMetricVal := by + have h := LinearMap.congr_fun (leftMetric.isIntertwining' M) (1 : ℂ) + simpa [leftMetric_apply_one, Representation.tprod_apply] using h.symm + /-- The metric `εₐₐ` as an element of `(dualLeftHanded ⊗ dualLeftHanded).V`. -/ def dualLeftMetricVal : (DualLeftHandedWeyl ⊗[ℂ] DualLeftHandedWeyl) := dualLeftdualLeftToMatrix.symm metricRaw diff --git a/Physlib/Relativity/IsLorentzDeriv.lean b/Physlib/Relativity/IsLorentzDeriv.lean new file mode 100644 index 000000000..0a13606ea --- /dev/null +++ b/Physlib/Relativity/IsLorentzDeriv.lean @@ -0,0 +1,483 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.RingTheory.GradedAlgebra.Basic +public import Mathlib.Algebra.DirectSum.Internal +public import Mathlib.LinearAlgebra.Eigenspace.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +/-! +# Class IsLorentzDeriv + +A family of operators indexed by the four spacetime directions is a **Lorentz derivative** +when the representation of `SL(2,ℂ)` intertwines it through the columns of the Lorentz +matrix, as the jet derivatives on a jet algebra do. + +Along the `i`-th spatial axis the four operators regroup into the two light-cone +combinations `lightConePlus D i = D_0 - D_i` and `lightConeMinus D i = D_0 + D_i`, which +shift every boost weight by `+2` and `-2` respectively, and the two transverse operators, +which preserve it. Consequently the weight-`k` part of the span of all derivative images of +a submodule redistributes onto the shifted weight projections +(`boostProj_map_submodule_x/y/z`). + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups TensorProduct +open scoped Pointwise + +variable {A : Type} [Ring A] [Algebra ℂ A] + +/-- The iterated operator `D_s = D_{ν₁} ⋯ D_{νₙ}` of a pairwise-commuting family of + endomorphisms along a multiset `s` of indices. Commutativity is what makes the + operator well-defined on a multiset, i.e. independent of any ordering of `s`. -/ +def iteratedD {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) (s : Multiset ι) : A →ₗ[ℂ] A := + letI : LeftCommutative (fun (ν : ι) (L : A →ₗ[ℂ] A) => (D ν).comp L) := + ⟨fun i j L => by rw [← LinearMap.comp_assoc, ← LinearMap.comp_assoc, hD]⟩ + s.foldr (fun ν L => (D ν).comp L) LinearMap.id + +lemma iteratedD_zero {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) : + iteratedD D hD (0 : Multiset ι) = LinearMap.id := by + simp only [iteratedD, Multiset.foldr_zero] + +lemma iteratedD_cons {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) (κ : ι) (s : Multiset ι) : + iteratedD D hD (κ ::ₘ s) = (D κ).comp (iteratedD D hD s) := by + simp only [iteratedD, Multiset.foldr_cons] + +/-- The iterated operator of a singleton is the operator itself. -/ +lemma iteratedD_singleton {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) (κ : ι) : + iteratedD D hD {κ} = D κ := by + rw [show ({κ} : Multiset ι) = κ ::ₘ 0 from rfl, iteratedD_cons, iteratedD_zero, + LinearMap.comp_id] + +/-- The iterated operator is additive in the multiset of directions: applying along + `s + t` is applying along `t` and then along `s`. -/ +lemma iteratedD_add {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) (s t : Multiset ι) : + iteratedD D hD (s + t) = (iteratedD D hD s).comp (iteratedD D hD t) := by + induction s using Multiset.induction_on with + | empty => rw [zero_add, iteratedD_zero, LinearMap.id_comp] + | cons κ s ih => + rw [Multiset.cons_add, iteratedD_cons, iteratedD_cons, ih, LinearMap.comp_assoc] + +/-- The companion of `iteratedD_cons`, peeling the new operator on the inside: for a + commuting family the extra operator may equally be applied first. -/ +lemma iteratedD_cons' {ι : Type*} (D : ι → A →ₗ[ℂ] A) + (hD : ∀ i j, (D i).comp (D j) = (D j).comp (D i)) (κ : ι) (s : Multiset ι) : + iteratedD D hD (κ ::ₘ s) = (iteratedD D hD s).comp (D κ) := by + rw [show (κ ::ₘ s) = s + {κ} from by rw [← Multiset.singleton_add, add_comm], + iteratedD_add, iteratedD_singleton] + +lemma iteratedD_mul (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) + (D_comm : ∀ μ ν, (D μ).comp (D ν) = (D ν).comp (D μ)) + (D_mul : ∀ (μ : Fin 1 ⊕ Fin 3) (b₁ b₂ : A), + D μ (b₁ * b₂) = D μ b₁ * b₂ + b₁ * D μ b₂) + (s : Multiset (Fin 1 ⊕ Fin 3)) (b₁ b₂ : A) : + Lorentz.iteratedD D D_comm s (b₁ * b₂) = + (s.antidiagonal.map fun p => + Lorentz.iteratedD D D_comm p.1 b₁ * Lorentz.iteratedD D D_comm p.2 b₂).sum := by + induction s using Multiset.induction_on with + | empty => simp [Lorentz.iteratedD_zero] + | cons κ s ih => + have hterm : ∀ p : Multiset (Fin 1 ⊕ Fin 3) × Multiset (Fin 1 ⊕ Fin 3), + D κ (Lorentz.iteratedD D D_comm p.1 b₁ * Lorentz.iteratedD D D_comm p.2 b₂) = + Lorentz.iteratedD D D_comm (κ ::ₘ p.1) b₁ * Lorentz.iteratedD D D_comm p.2 b₂ + + Lorentz.iteratedD D D_comm p.1 b₁ * + Lorentz.iteratedD D D_comm (κ ::ₘ p.2) b₂ := by + intro p + rw [D_mul, Lorentz.iteratedD_cons, Lorentz.iteratedD_cons, + LinearMap.comp_apply, LinearMap.comp_apply] + rw [Lorentz.iteratedD_cons, LinearMap.comp_apply, ih, map_multiset_sum, + Multiset.map_map] + simp only [Function.comp_def] + rw [Multiset.map_congr rfl fun p _ => hterm p, Multiset.sum_map_add, + Multiset.antidiagonal_cons, Multiset.map_add, Multiset.sum_add, Multiset.map_map, + Multiset.map_map] + simp only [Function.comp_def, Prod.map, id_eq] + abel + + +/-- A family of operators indexed by the spacetime directions is a **Lorentz derivative** + when the representation of `SL(2,ℂ)` intertwines it through the columns of the Lorentz + matrix. The class needs only the module structure, so it applies uniformly to any + representation space. -/ +class IsLorentzDeriv {M : Type} [AddCommMonoid M] [Module ℂ M] + (rep : Representation ℂ SL(2,ℂ) M) (D : (Fin 1 ⊕ Fin 3) → M →ₗ[ℂ] M) where + rep_deriv {Λ μ x} : rep Λ (D μ x) = + ∑ a, (((SL2C.toLorentzGroup Λ).1 a μ : ℝ) : ℂ) • D a (rep Λ x) + +/-- A family of derivative symbols `F : s ↦ [∂_s ψ^φ]`, indexed by the dual of a value + space `V` carrying a representation of `SL(2,ℂ)`, **transforms as the derivative + symbols of a Lorentz-covariant field**: each ordered symbol mixes into all tuples of + directions by the per-slot columns of the Lorentz matrix, while the value index + transforms by the contragredient action `rep.dual` on the dual of `V`. This is the + general form of the `lorentz_apply` field of `IsGaugeField`, for a field valued in an + arbitrary Lorentz representation — the trivial representation for scalars, the Weyl + representations for fermions, and their conjugates for the barred fields. At `n = 0` + it reduces to the homogeneous law `Λ • F₀^φ = F₀^{Λ^{-⊤} φ}`. -/ +def IsLorentzDerivTransforms {k V : Type*} [CommRing k] [AddCommGroup V] [Module k V] + [Module k A] + (repLorentz : Representation ℂ SL(2,ℂ) A) (rep : Representation k SL(2,ℂ) V) + (F : Multiset (Fin 1 ⊕ Fin 3) → Module.Dual k V →ₗ[k] A) : Prop := + ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual k V), + repLorentz Λ (F (List.ofFn l) φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + F (List.ofFn p) (rep.dual Λ φ) + +/-- A family of *covariant*-derivative symbols, indexed by ordered tuples of + directions (covariant derivatives do not commute) and by the dual of a Lorentz + representation `V`, **transforms as the covariant derivatives of a + Lorentz-covariant field**: each derivative slot mixes by the columns of the Lorentz + matrix, while the value index transforms by the contragredient action `rep.dual` on + the dual of `V` — the ordered-tuple analogue of `IsLorentzDerivTransforms`. -/ +def IsLorentzCovDerivTransforms {k V : Type*} [CommRing k] [AddCommGroup V] + [Module k V] [Module k A] (repLorentz : Representation ℂ SL(2,ℂ) A) + (rep : Representation k SL(2,ℂ) V) + (F : {n : ℕ} → (Fin n → (Fin 1 ⊕ Fin 3)) → Module.Dual k V →ₗ[k] A) : Prop := + ∀ (Λ : SL(2,ℂ)) (n : ℕ) (l : Fin n → (Fin 1 ⊕ Fin 3)) (φ : Module.Dual k V), + repLorentz Λ (F l φ) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + F p (rep.dual Λ φ) + +namespace IsLorentzDeriv + +variable {rep : Representation ℂ SL(2,ℂ) A} {D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A} + +/-- The scalar action of a real parameter, in the form the weight condition presents it. -/ +private lemma algebraMap_real_complex (t : ℝ) : (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) := rfl + +/-- **The Lorentz transformation of iterated derivatives**: for a Lorentz derivative the + ordered derivative symbol `D_{l 0} ⋯ D_{l (n-1)} x` mixes into all tuples of + directions, with one Lorentz matrix factor per slot. -/ +lemma rep_iteratedD_ofFn [IsLorentzDeriv rep D] + (D_comm : ∀ μ ν, (D μ).comp (D ν) = (D ν).comp (D μ)) + (Λ : SL(2,ℂ)) {n : ℕ} (l : Fin n → (Fin 1 ⊕ Fin 3)) (x : A) : + rep Λ (iteratedD D D_comm (List.ofFn l) x) = + ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + iteratedD D D_comm (List.ofFn p) (rep Λ x) := by + induction n with + | zero => + rw [List.ofFn_zero, + show ((([] : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) = 0) from rfl, + iteratedD_zero, Fintype.sum_unique] + simp [List.ofFn_zero, iteratedD_zero] + | succ n ih => + have hstep : ∀ (a : Fin 1 ⊕ Fin 3) (p : Fin n → (Fin 1 ⊕ Fin 3)), + ((List.ofFn (Fin.cons a p) : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3)) = + a ::ₘ ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) := by + intro a p + rw [List.ofFn_succ] + simp only [Fin.cons_zero, Fin.cons_succ] + rfl + calc rep Λ (iteratedD D D_comm (List.ofFn l) x) + = ∑ a, (((SL2C.toLorentzGroup Λ).1 a (l 0) : ℝ) : ℂ) • + D a (rep Λ (iteratedD D D_comm + (List.ofFn fun i : Fin n => l i.succ) x)) := by + rw [show ((List.ofFn l : List (Fin 1 ⊕ Fin 3)) : Multiset (Fin 1 ⊕ Fin 3)) = + l 0 ::ₘ ((List.ofFn fun i : Fin n => l i.succ : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3)) from by rw [List.ofFn_succ]; rfl, + iteratedD_cons, LinearMap.comp_apply, rep_deriv] + _ = ∑ a, ∑ p : Fin n → (Fin 1 ⊕ Fin 3), + ((((SL2C.toLorentzGroup Λ).1 a (l 0) : ℝ) : ℂ) * + ∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) • + iteratedD D D_comm (a ::ₘ ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3))) (rep Λ x) := by + refine Finset.sum_congr rfl fun a _ => ?_ + rw [ih (fun i => l i.succ), map_sum, Finset.smul_sum] + refine Finset.sum_congr rfl fun p _ => ?_ + rw [map_smul, smul_smul, iteratedD_cons, LinearMap.comp_apply] + _ = ∑ p : Fin (n + 1) → (Fin 1 ⊕ Fin 3), + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + iteratedD D D_comm (List.ofFn p) (rep Λ x) := by + rw [← Equiv.sum_comp (Fin.consEquiv fun _ : Fin (n + 1) => (Fin 1 ⊕ Fin 3)) + (fun p : Fin (n + 1) → (Fin 1 ⊕ Fin 3) => + (∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i) : ℝ) : ℂ)) • + iteratedD D D_comm (List.ofFn p) (rep Λ x)), + Fintype.sum_prod_type] + refine Finset.sum_congr rfl fun a _ => Finset.sum_congr rfl fun p _ => ?_ + show ((((SL2C.toLorentzGroup Λ).1 a (l 0) : ℝ) : ℂ) * + ∏ i, (((SL2C.toLorentzGroup Λ).1 (p i) (l i.succ) : ℝ) : ℂ)) • + iteratedD D D_comm (a ::ₘ ((List.ofFn p : List (Fin 1 ⊕ Fin 3)) : + Multiset (Fin 1 ⊕ Fin 3))) (rep Λ x) = + (∏ i, (((SL2C.toLorentzGroup Λ).1 + ((Fin.cons a p : Fin (n + 1) → (Fin 1 ⊕ Fin 3)) i) (l i) : ℝ) : ℂ)) • + iteratedD D D_comm + (List.ofFn (Fin.cons a p : Fin (n + 1) → (Fin 1 ⊕ Fin 3))) (rep Λ x) + rw [Fin.prod_univ_succ, hstep a p] + simp only [Fin.cons_zero, Fin.cons_succ] + +/-! + +## A. Light cone derivatives + +-/ + +/-- The light-cone combination `D_0 - D_i`, raising every boost weight along the `i`-th + axis by two (`lightConePlus_mem`). -/ +def lightConePlus (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) (i : Fin 3) : A →ₗ[ℂ] A := + D (Sum.inl 0) - D (Sum.inr i) + +/-- The light-cone combination `D_0 + D_i`, lowering every boost weight along the `i`-th + axis by two (`lightConeMinus_mem`). -/ +def lightConeMinus (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) (i : Fin 3) : A →ₗ[ℂ] A := + D (Sum.inl 0) + D (Sum.inr i) + +/-! + +## B. Relationship to boost weights + +-/ + +section + +/-- A transverse Lorentz derivative leaves the boost weight along the `i`-th axis alone. -/ +lemma transverse_mem [IsLorentzDeriv rep D] {i j : Fin 3} (hij : j ≠ i) {k : ℤ} {x : A} + (hx : x ∈ BoostWeight.boostWeightSubmodule rep i k) : + D (Sum.inr j) x ∈ BoostWeight.boostWeightSubmodule rep i k := by + intro t ht + rw [rep_deriv, hx t ht, algebraMap_real_complex] + rw [show Lorentz.SL2C.toLorentzGroup (Lorentz.SL2C.boostAxis i t ht) = + LorentzGroup.boostAxis i t ht from rfl] + fin_cases i <;> fin_cases j <;> + first + | exact absurd rfl hij + | simp [LorentzGroup.boostAxis_apply] + +/-- The light-cone combination `D_0 - D_i` raises the boost weight along the `i`-th axis + by two. -/ +lemma lightConePlus_mem [IsLorentzDeriv rep D] {i : Fin 3} {k : ℤ} {x : A} + (hx : x ∈ BoostWeight.boostWeightSubmodule rep i k) : + lightConePlus D i x ∈ BoostWeight.boostWeightSubmodule rep i (k + 2) := by + intro t ht + have ht' : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + simp only [lightConePlus, LinearMap.sub_apply] + rw [map_sub, rep_deriv, rep_deriv, hx t ht] + rw [algebraMap_real_complex, zpow_add₀ ht'] + rw [show Lorentz.SL2C.toLorentzGroup (Lorentz.SL2C.boostAxis i t ht) = + LorentzGroup.boostAxis i t ht from rfl] + fin_cases i + all_goals + simp [LorentzGroup.boostAxis_apply, Fintype.sum_sum_type, Fin.sum_univ_three] + match_scalars <;> (field_simp [ht']; noncomm_ring) + +/-- The light-cone combination `D_0 + D_i` lowers the boost weight along the `i`-th axis + by two. -/ +lemma lightConeMinus_mem [IsLorentzDeriv rep D] {i : Fin 3} {k : ℤ} {x : A} + (hx : x ∈ BoostWeight.boostWeightSubmodule rep i k) : + lightConeMinus D i x ∈ BoostWeight.boostWeightSubmodule rep i (k - 2) := by + intro t ht + have ht' : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + simp only [lightConeMinus, LinearMap.add_apply] + rw [map_add, rep_deriv, rep_deriv, hx t ht] + rw [algebraMap_real_complex, zpow_sub₀ ht'] + rw [show Lorentz.SL2C.toLorentzGroup (Lorentz.SL2C.boostAxis i t ht) = + LorentzGroup.boostAxis i t ht from rfl] + fin_cases i + all_goals + simp [LorentzGroup.boostAxis_apply, Fintype.sum_sum_type, Fin.sum_univ_three] + match_scalars <;> (field_simp [ht']; noncomm_ring) + +end + +/-! + +## The boost projections of the span of the derivative images + +-/ + +/-- Two composites agreeing on a submodule have the same double image. -/ +private lemma map_map_eq_of_forall_mem {f g f' g' : A →ₗ[ℂ] A} + {V : Submodule ℂ A} (h : ∀ x ∈ V, g (f x) = g' (f' x)) : + (V.map f).map g = (V.map f').map g' := by + refine le_antisymm ?_ ?_ + · rintro _ ⟨_, ⟨v, hv, rfl⟩, rfl⟩ + exact ⟨f' v, ⟨v, hv, rfl⟩, (h v hv).symm⟩ + · rintro _ ⟨_, ⟨v, hv, rfl⟩, rfl⟩ + exact ⟨f v, ⟨v, hv, rfl⟩, h v hv⟩ + +/-- The images under `D_0` and `D_i` span the same submodule as the images under the two + light-cone combinations. -/ +lemma map_pair_eq_lightCone (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) (i : Fin 3) + (V : Submodule ℂ A) : + V.map (D (Sum.inl 0)) + V.map (D (Sum.inr i)) = + V.map (lightConePlus D i) + V.map (lightConeMinus D i) := by + rw [Submodule.add_eq_sup, Submodule.add_eq_sup] + refine le_antisymm (sup_le ?_ ?_) (sup_le ?_ ?_) + · rintro _ ⟨v, hv, rfl⟩ + rw [show D (Sum.inl 0) v = + (2⁻¹ : ℂ) • lightConePlus D i v + (2⁻¹ : ℂ) • lightConeMinus D i v from by + simp only [lightConePlus, lightConeMinus, LinearMap.sub_apply, LinearMap.add_apply] + module] + exact add_mem (Submodule.smul_mem _ _ (Submodule.mem_sup_left ⟨v, hv, rfl⟩)) + (Submodule.smul_mem _ _ (Submodule.mem_sup_right ⟨v, hv, rfl⟩)) + · rintro _ ⟨v, hv, rfl⟩ + rw [show D (Sum.inr i) v = + (-2⁻¹ : ℂ) • lightConePlus D i v + (2⁻¹ : ℂ) • lightConeMinus D i v from by + simp only [lightConePlus, lightConeMinus, LinearMap.sub_apply, LinearMap.add_apply] + module] + exact add_mem (Submodule.smul_mem _ _ (Submodule.mem_sup_left ⟨v, hv, rfl⟩)) + (Submodule.smul_mem _ _ (Submodule.mem_sup_right ⟨v, hv, rfl⟩)) + · rintro _ ⟨v, hv, rfl⟩ + simp only [lightConePlus, LinearMap.sub_apply] + exact sub_mem (Submodule.mem_sup_left ⟨v, hv, rfl⟩) + (Submodule.mem_sup_right ⟨v, hv, rfl⟩) + · rintro _ ⟨v, hv, rfl⟩ + simp only [lightConeMinus, LinearMap.add_apply] + exact add_mem (Submodule.mem_sup_left ⟨v, hv, rfl⟩) + (Submodule.mem_sup_right ⟨v, hv, rfl⟩) + +/-- The engine behind the three axis lemmas: the projection of the four derivative images + redistributes onto the shifted projections of `V`. -/ +private lemma boostProj_map_submodule_aux [BoostWeight.IsBoostGraded rep] + [IsLorentzDeriv rep D] {i t₁ t₂ : Fin 3} (ht₁ : t₁ ≠ i) (ht₂ : t₂ ≠ i) (k : ℤ) + (V : Submodule ℂ A) : + (V.map (D (Sum.inl 0)) + V.map (D (Sum.inr i)) + V.map (D (Sum.inr t₁)) + + V.map (D (Sum.inr t₂))).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i (k - 2))).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr t₁)) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr t₂)) := by + have hlcp : (V.map (lightConePlus D i)).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i (k - 2))).map (lightConePlus D i) := by + refine map_map_eq_of_forall_mem fun v _ => ?_ + refine BoostWeight.boostProj_comm rep k (k - 2) (fun {w} {y} hyw => ?_) v + rw [show w + k - (k - 2) = w + 2 from by ring] + exact lightConePlus_mem hyw + have hlcn : (V.map (lightConeMinus D i)).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i (k + 2))).map (lightConeMinus D i) := by + refine map_map_eq_of_forall_mem fun v _ => ?_ + refine BoostWeight.boostProj_comm rep k (k + 2) (fun {w} {y} hyw => ?_) v + rw [show w + k - (k + 2) = w - 2 from by ring] + exact lightConeMinus_mem hyw + have hd₁ : (V.map (D (Sum.inr t₁))).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr t₁)) := by + refine map_map_eq_of_forall_mem fun v _ => ?_ + refine BoostWeight.boostProj_comm rep k k (fun {w} {y} hyw => ?_) v + rw [show w + k - k = w from by ring] + exact transverse_mem ht₁ hyw + have hd₂ : (V.map (D (Sum.inr t₂))).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr t₂)) := by + refine map_map_eq_of_forall_mem fun v _ => ?_ + refine BoostWeight.boostProj_comm rep k k (fun {w} {y} hyw => ?_) v + rw [show w + k - k = w from by ring] + exact transverse_mem ht₂ hyw + rw [map_pair_eq_lightCone] + simp only [Submodule.add_eq_sup, Submodule.map_sup, hlcp, hlcn, hd₁, hd₂] + +/-- **The boost projections of the span of Lorentz derivatives, along any axis.** The + weight-`k` part of the span of the four derivative images of `V` is spanned by the + light-cone combinations applied to the weight-`(k ∓ 2)` parts of `V` together with the two + transverse derivatives, at directions `i + 1` and `i + 2`, of its weight-`k` part. -/ +lemma boostProj_map_deriv_map_submodule [BoostWeight.IsBoostGraded rep] + [IsLorentzDeriv rep D] (k : ℤ) (V : Submodule ℂ A) (i : Fin 3) : + (∑ α, V.map (D α)).map (BoostWeight.boostProj rep i k) = + (V.map (BoostWeight.boostProj rep i (k - 2))).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 1))) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 2))) := by + have hsum : (∑ α, V.map (D α)) = + V.map (D (Sum.inl 0)) + V.map (D (Sum.inr i)) + V.map (D (Sum.inr (i + 1))) + + V.map (D (Sum.inr (i + 2))) := by + rw [Fintype.sum_sum_type, Fin.sum_univ_one, Fin.sum_univ_three] + fin_cases i <;> + (simp only [Fin.isValue, Fin.zero_eta, Fin.mk_one, Fin.reduceFinMk, Fin.reduceAdd]; abel) + rw [hsum] + exact boostProj_map_submodule_aux (by fin_cases i <;> decide) (by fin_cases i <;> decide) k V + +/-- **Two derivative layers.** The weight-`k` part of the span of all second derivative + images of `V` redistributes onto the weight `k - 4, …, k + 4` parts of `V`, hit by the + light-cone and transverse operators twice over: `boostProj_map_deriv_map_submodule` + applied at the outer layer and then to each of the three inner projected spans. -/ +lemma boostProj_map_deriv_map_deriv_map [BoostWeight.IsBoostGraded rep] [IsLorentzDeriv rep D] + (k : ℤ) (V : Submodule ℂ A) (i : Fin 3) : + (∑ β, (∑ α, V.map (D α)).map (D β)).map (BoostWeight.boostProj rep i k) = + ((V.map (BoostWeight.boostProj rep i (k - 4))).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i k)).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i (k - 2))).map (D (Sum.inr (i + 1))) + + (V.map (BoostWeight.boostProj rep i (k - 2))).map (D (Sum.inr (i + 2)))).map + (lightConePlus D i) + + ((V.map (BoostWeight.boostProj rep i k)).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i (k + 4))).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (D (Sum.inr (i + 1))) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (D (Sum.inr (i + 2)))).map + (lightConeMinus D i) + + ((V.map (BoostWeight.boostProj rep i (k - 2))).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 1))) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 2)))).map + (D (Sum.inr (i + 1))) + + ((V.map (BoostWeight.boostProj rep i (k - 2))).map (lightConePlus D i) + + (V.map (BoostWeight.boostProj rep i (k + 2))).map (lightConeMinus D i) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 1))) + + (V.map (BoostWeight.boostProj rep i k)).map (D (Sum.inr (i + 2)))).map + (D (Sum.inr (i + 2))) := by + rw [boostProj_map_deriv_map_submodule k _ i, boostProj_map_deriv_map_submodule (k - 2) V i, + boostProj_map_deriv_map_submodule (k + 2) V i, boostProj_map_deriv_map_submodule k V i, + show k - 2 - 2 = k - 4 from by ring, show k - 2 + 2 = k from by ring, + show k + 2 - 2 = k from by ring, show k + 2 + 2 = k + 4 from by ring] + +/-- The span of the derivative images of a weight-decomposed submodule is weight decomposed: + the projections stay inside it and the support widens by the light-cone shifts `±2`. -/ +noncomputable def _root_.Lorentz.BoostWeight.WeightDecomposition.deriv + [BoostWeight.IsBoostGraded rep] {i : Fin 3} {V : Submodule ℂ A} + (d : BoostWeight.WeightDecomposition rep i V) + (D : (Fin 1 ⊕ Fin 3) → A →ₗ[ℂ] A) [IsLorentzDeriv rep D] : + BoostWeight.WeightDecomposition rep i (∑ α, V.map (D α)) := by + classical + have hV : ∀ μ, V.map (D μ) ≤ ∑ α, V.map (D α) := fun μ => + Finset.single_le_sum (f := fun α => V.map (D α)) + (fun _ _ => by rw [Submodule.zero_eq_bot]; exact bot_le) (Finset.mem_univ μ) + have hsub : ∀ f g : A →ₗ[ℂ] A, V.map (f - g) ≤ V.map f ⊔ V.map g := by + rintro f g _ ⟨v, hv, rfl⟩ + rw [LinearMap.sub_apply] + exact sub_mem (Submodule.mem_sup_left ⟨v, hv, rfl⟩) + (Submodule.mem_sup_right ⟨v, hv, rfl⟩) + have hadd : ∀ f g : A →ₗ[ℂ] A, V.map (f + g) ≤ V.map f ⊔ V.map g := by + rintro f g _ ⟨v, hv, rfl⟩ + rw [LinearMap.add_apply] + exact add_mem (Submodule.mem_sup_left ⟨v, hv, rfl⟩) + (Submodule.mem_sup_right ⟨v, hv, rfl⟩) + refine BoostWeight.WeightDecomposition.ofMapClosed rep (d.supp + ({-2, 0, 2} : Finset ℤ)) + (fun k => ?_) (fun k hk => ?_) + · rw [boostProj_map_deriv_map_submodule k V i] + simp only [Submodule.add_eq_sup] + refine sup_le (sup_le (sup_le ?_ ?_) ?_) ?_ + · exact (Submodule.map_mono (d.map_boostProj_le _)).trans + ((hsub _ _).trans (sup_le (hV _) (hV _))) + · exact (Submodule.map_mono (d.map_boostProj_le _)).trans + ((hadd _ _).trans (sup_le (hV _) (hV _))) + · exact (Submodule.map_mono (d.map_boostProj_le _)).trans (hV _) + · exact (Submodule.map_mono (d.map_boostProj_le _)).trans (hV _) + · have h₁ : k - 2 ∉ d.supp := fun h => hk (by + simpa using Finset.add_mem_add h (show (2 : ℤ) ∈ ({-2, 0, 2} : Finset ℤ) by decide)) + have h₂ : k + 2 ∉ d.supp := fun h => hk (by + simpa using Finset.add_mem_add h (show (-2 : ℤ) ∈ ({-2, 0, 2} : Finset ℤ) by decide)) + have h₀ : k ∉ d.supp := fun h => hk (by + simpa using Finset.add_mem_add h (show (0 : ℤ) ∈ ({-2, 0, 2} : Finset ℤ) by decide)) + rw [boostProj_map_deriv_map_submodule k V i, d.map_boostProj_of_notMem h₁, + d.map_boostProj_of_notMem h₂, d.map_boostProj_of_notMem h₀] + simp + +end IsLorentzDeriv + +end Lorentz + +end diff --git a/Physlib/Relativity/JetRing/Basic.lean b/Physlib/Relativity/JetRing/Basic.lean new file mode 100644 index 000000000..d1317bbc1 --- /dev/null +++ b/Physlib/Relativity/JetRing/Basic.lean @@ -0,0 +1,435 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Mathlib.Data.Complex.Basic +public import Mathlib.LinearAlgebra.Complex.Module +public import Mathlib.Algebra.Star.BigOperators +public import Mathlib.Tactic.LinearCombination +public import Mathlib.RingTheory.MvPowerSeries.Basic +public import Mathlib.Data.Finsupp.Multiset +public import Mathlib.Data.Finsupp.Weight +public import Physlib.Mathematics.MvPowerSeriesDerivative +public import Physlib.Mathematics.ConjModule +/-! +# The jet ring + +The ring `JetRing` of formal power series in the four spacetime coordinates, in +which jets of fields and of gauge transformations at a spacetime point are valued. + +This file contains the definition of `JetRing`, its star structure, first-order +coefficient identities, the formal partial derivative, and the truncation of jets. +Results about matrices over `JetRing` are in +`Physlib.Relativity.JetRing.Matrix`. +-/ + +@[expose] public section +/-! + +## A. The Jet ring + +-/ + +/-- The ring of formal power series in the four spacetime coordinates, with complex + coefficients. Jets of fields and of gauge transformations at a spacetime point are + valued in this ring. The star operation is coefficientwise complex conjugation, so + the spacetime coordinates themselves are self-adjoint. -/ +abbrev JetRing : Type := MvPowerSeries (Fin 1 ⊕ Fin 3) ℂ + +/-! + +### A.1. The star structure on the jet ring + +The star operation on the jet ring is coefficientwise complex conjugation, fixing +the formal variables. In particular the spacetime coordinates are self-adjoint. + +-/ + +namespace JetRing + +open MvPowerSeries + +instance : Star JetRing where + star f := fun n => star (f n) + +@[simp] +lemma coeff_star (n : (Fin 1 ⊕ Fin 3) →₀ ℕ) (f : JetRing) : + coeff n (star f) = star (coeff n f) := rfl + +instance : StarRing JetRing where + star_involutive f := funext fun n => star_star (f n) + star_add f g := funext fun n => star_add (f n) (g n) + star_mul f g := by + have h : ∀ a b : JetRing, star (a * b) = star a * star b := by + intro a b + ext n + classical + rw [coeff_star, coeff_mul, coeff_mul, star_sum] + exact Finset.sum_congr rfl fun p _ => by rw [star_mul', coeff_star, coeff_star] + rw [h, mul_comm] + +/-- Real scalars commute with the coefficientwise conjugation. -/ +instance : StarModule ℝ JetRing where + star_smul r f := funext fun n => star_smul r (f n) + +/-- Complex scalars conjugate under the coefficientwise conjugation. -/ +instance : StarModule ℂ JetRing where + star_smul c f := funext fun n => star_smul c (f n) + +@[simp] +lemma constantCoeff_star (f : JetRing) : + constantCoeff (star f) = star (constantCoeff f) := rfl + +@[simp] +lemma star_C (a : ℂ) : + star (C a : JetRing) = C (star a) := by + ext n + classical + rw [coeff_star, coeff_C, coeff_C] + split_ifs <;> simp + +/-- **The real structure of the jet ring.** Coefficientwise conjugation is a `ℂ`-linear +equivalence from the conjugate module of the jet ring back to the jet ring itself. It is +honestly `ℂ`-linear, not merely semilinear, because the conjugate-linearity of `star` +cancels against the twisted scalar action of `ConjModule`. + +This is what identifies the jets of a conjugate field with the conjugates of the jets: +`ConjModule (JetRing ⊗[ℂ] V)` and `JetRing ⊗[ℂ] ConjModule V` differ exactly by this +equivalence on the jet-ring factor. -/ +noncomputable def starConjEquiv : ConjModule JetRing ≃ₗ[ℂ] JetRing := + (conjEquiv (k := ℂ) (M := JetRing)).symm.trans (starLinearEquiv ℂ) + +@[simp] +lemma starConjEquiv_apply (f : ConjModule JetRing) : + starConjEquiv f = star ((conjEquiv (k := ℂ) (M := JetRing)).symm f) := rfl + +@[simp] +lemma starConjEquiv_symm_apply (f : JetRing) : + starConjEquiv.symm f = conjEquiv (k := ℂ) (M := JetRing) (star f) := rfl + +/-- The first-order Leibniz rule: the degree-one Taylor coefficient, in the + direction `μ`, of a product of jets. This is the coefficient-level statement + that the first jet of a product is given by the product rule. -/ +lemma coeff_single_one_mul (μ : Fin 1 ⊕ Fin 3) (f g : JetRing) : + coeff (Finsupp.single μ 1) (f * g) = + coeff (Finsupp.single μ 1) f * constantCoeff g + + constantCoeff f * coeff (Finsupp.single μ 1) g := by + classical + rw [coeff_mul, Finsupp.antidiagonal_single, + show Finset.antidiagonal (1 : ℕ) = {(0, 1), (1, 0)} by decide, Finset.map_insert, + Finset.map_singleton, Finset.sum_insert (by simp [Finsupp.single_eq_zero]), + Finset.sum_singleton] + simp only [Function.Embedding.coe_prodMap, Function.Embedding.coeFn_mk, Prod.map_apply, + Finsupp.single_zero, coeff_zero_eq_constantCoeff] + ring + +/-- The first-order power rule: the degree-one Taylor coefficient, in the direction + `μ`, of a power of a jet. -/ +lemma coeff_single_one_pow (μ : Fin 1 ⊕ Fin 3) (f : JetRing) (n : ℕ) : + coeff (Finsupp.single μ 1) (f ^ n) = + (n : ℂ) * constantCoeff f ^ (n - 1) * coeff (Finsupp.single μ 1) f := by + classical + induction n with + | zero => + simp [coeff_one, Finsupp.single_eq_zero] + | succ n ih => + rw [pow_succ, coeff_single_one_mul, ih, map_pow, Nat.add_sub_cancel] + rcases Nat.eq_zero_or_pos n with hn | hn + · subst hn + simp + · have hpow : constantCoeff f ^ (n - 1) * constantCoeff f = constantCoeff f ^ n := by + rw [← pow_succ, Nat.sub_add_cancel hn] + push_cast + linear_combination ((n : ℂ) * coeff (Finsupp.single μ 1) f) * hpow + +/-! + +### A.2. The formal partial derivative on the jet ring + +-/ + +/-- The formal partial derivative commutes with the coefficientwise star. -/ +lemma pderiv_star (ν : Fin 1 ⊕ Fin 3) (f : JetRing) : + pderiv ℂ ν (star f) = star (pderiv ℂ ν f) := by + ext s + rw [coeff_pderiv, coeff_star, coeff_star, coeff_pderiv, star_mul'] + congr 1 + simp + +/-- Formal partial derivatives commute. -/ +lemma pderiv_comm (μ ν : Fin 1 ⊕ Fin 3) (f : JetRing) : + pderiv ℂ μ (pderiv ℂ ν f) = pderiv ℂ ν (pderiv ℂ μ f) := by + classical + ext s + rw [coeff_pderiv, coeff_pderiv, coeff_pderiv, coeff_pderiv, + show s + Finsupp.single μ 1 + Finsupp.single ν 1 = + s + Finsupp.single ν 1 + Finsupp.single μ 1 from by + rw [add_assoc, add_assoc, add_comm (Finsupp.single μ 1)]] + rcases eq_or_ne μ ν with rfl | h + · rfl + · rw [Finsupp.add_apply, Finsupp.add_apply, Finsupp.single_eq_of_ne h.symm, + Finsupp.single_eq_of_ne h] + push_cast + ring + +/-- Application of `pderiv` is right-commutative, since formal partial derivatives + commute (`JetRing.pderiv_comm`). This allows iterating them over a `Multiset` of + directions. -/ +instance : RightCommutative (fun (f : JetRing) (μ : Fin 1 ⊕ Fin 3) => pderiv ℂ μ f) where + right_comm f μ ν := JetRing.pderiv_comm ν μ f + +/-- Iterated formal derivatives over a multiset commute with a single derivative. -/ +lemma foldl_pderiv_pderiv (s : Multiset (Fin 1 ⊕ Fin 3)) (μ : Fin 1 ⊕ Fin 3) (f : JetRing) : + s.foldl (fun f ρ => pderiv ℂ ρ f) (pderiv ℂ μ f) = + pderiv ℂ μ (s.foldl (fun f ρ => pderiv ℂ ρ f) f) := by + induction s using Multiset.induction_on generalizing f with + | empty => simp + | cons a t ih => + rw [Multiset.foldl_cons, Multiset.foldl_cons, JetRing.pderiv_comm, ih] + +/-! + +### Truncation of jets + +-/ +/-- The `n`-th truncation of a jet: the Taylor coefficients of total degree + greater than `n` are set to zero. -/ +noncomputable def truncation (n : ℕ) (f : JetRing) : JetRing := + fun m => if Finsupp.degree m ≤ n then f m else 0 + +@[simp] +lemma coeff_truncation_of_le {n : ℕ} {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} + (h : Finsupp.degree m ≤ n) (f : JetRing) : + coeff m (truncation n f) = coeff m f := if_pos h + +@[simp] +lemma coeff_truncation_of_gt {n : ℕ} {m : (Fin 1 ⊕ Fin 3) →₀ ℕ} + (h : n < Finsupp.degree m) (f : JetRing) : + coeff m (truncation n f) = 0 := if_neg (not_le.mpr h) + +lemma truncation_add (n : ℕ) (f g : JetRing) : + truncation n (f + g) = truncation n f + truncation n g := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [coeff_truncation_of_le hm, map_add, map_add, + coeff_truncation_of_le hm, coeff_truncation_of_le hm] + · rw [coeff_truncation_of_gt (not_le.mp hm), map_add, + coeff_truncation_of_gt (not_le.mp hm), coeff_truncation_of_gt (not_le.mp hm), add_zero] + +lemma truncation_sum {ι : Type} (n : ℕ) (s : Finset ι) (f : ι → JetRing) : + truncation n (∑ i ∈ s, f i) = ∑ i ∈ s, truncation n (f i) := + map_sum (AddMonoidHom.mk' (truncation n) (truncation_add n)) f s + +/-- Truncation of a product only sees the factors through their truncations: the + coefficients of `f * g` in degree at most `n` involve only coefficients of `f` + and `g` in degree at most `n`. -/ +lemma truncation_mul (n : ℕ) (f g : JetRing) : + truncation n (f * g) = truncation n (truncation n f * truncation n g) := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [coeff_truncation_of_le hm, coeff_truncation_of_le hm, coeff_mul, coeff_mul] + refine Finset.sum_congr rfl fun p hp => ?_ + have hpq : p.1 + p.2 = m := Finset.mem_antidiagonal.mp hp + have h1 : Finsupp.degree p.1 ≤ n := by + refine le_trans ?_ hm + rw [← hpq, map_add] + exact Nat.le_add_right _ _ + have h2 : Finsupp.degree p.2 ≤ n := by + refine le_trans ?_ hm + rw [← hpq, map_add] + exact Nat.le_add_left _ _ + rw [coeff_truncation_of_le h1, coeff_truncation_of_le h2] + · rw [coeff_truncation_of_gt (not_le.mp hm), coeff_truncation_of_gt (not_le.mp hm)] + +/-- The congruence principle for truncated products. -/ +lemma truncation_mul_congr {n : ℕ} {f f' g g' : JetRing} + (hf : truncation n f = truncation n f') (hg : truncation n g = truncation n g') : + truncation n (f * g) = truncation n (f' * g') := by + rw [truncation_mul, hf, hg, ← truncation_mul] + +lemma truncation_star (n : ℕ) (f : JetRing) : + truncation n (star f) = star (truncation n f) := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [coeff_truncation_of_le hm, coeff_star, coeff_star, coeff_truncation_of_le hm] + · rw [coeff_truncation_of_gt (not_le.mp hm), coeff_star, + coeff_truncation_of_gt (not_le.mp hm), star_zero] +@[simp] +lemma truncation_zero (n : ℕ) : truncation n (0 : JetRing) = 0 := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [coeff_truncation_of_le hm] + · rw [coeff_truncation_of_gt (not_le.mp hm), map_zero] + +/-- Truncation fixes the identity: a constant series has its only nonzero Taylor + coefficient in degree zero, which every truncation keeps. -/ +@[simp] +lemma truncation_one (n : ℕ) : truncation n (1 : JetRing) = 1 := by + ext m + by_cases hm : Finsupp.degree m ≤ n + · rw [coeff_truncation_of_le hm] + · rw [coeff_truncation_of_gt (not_le.mp hm), coeff_one, + if_neg (by rintro rfl; simp at hm)] + +/-- Two jets have the same zeroth truncation exactly when they have the same + value at the base point. -/ +lemma truncation_zero_eq_iff {f g : JetRing} : + truncation 0 f = truncation 0 g ↔ constantCoeff f = constantCoeff g := by + constructor + · intro h + simpa using congrArg (coeff (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ)) h + · intro h + ext m + by_cases hm : Finsupp.degree m ≤ 0 + · have hm0 : m = 0 := (Finsupp.degree_eq_zero_iff m).mp (Nat.le_zero.mp hm) + subst hm0 + simpa using h + · rw [coeff_truncation_of_gt (not_le.mp hm), coeff_truncation_of_gt (not_le.mp hm)] + + +/-! + +## The Euler operator toolkit + +-/ + +/-- The formal coordinates of the jet ring are self-adjoint. -/ +lemma star_X (ρ : Fin 1 ⊕ Fin 3) : star (X ρ : JetRing) = X ρ := by + ext m + rw [JetRing.coeff_star, show (X ρ : JetRing) = monomial (Finsupp.single ρ 1) 1 from rfl, + coeff_monomial] + split_ifs <;> simp + +/-- The Taylor coefficients of a jet multiplied by a formal coordinate: the + coefficient shifts down by one in that direction. -/ +lemma coeff_X_smul (ρ : Fin 1 ⊕ Fin 3) (f : JetRing) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + coeff p ((X ρ : JetRing) • f) = + if Finsupp.single ρ 1 ≤ p then coeff (p - Finsupp.single ρ 1) f else 0 := by + rw [smul_eq_mul, show (X ρ : JetRing) = monomial (Finsupp.single ρ 1) 1 from rfl, + coeff_monomial_mul] + split_ifs <;> simp + +/-- The Euler (radial) operator acts on Taylor coefficients as multiplication by the + total degree. -/ +lemma coeff_sum_X_smul_pderiv (f : JetRing) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) : + coeff p (∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ f) = + ((Finsupp.degree p : ℕ) : ℂ) * coeff p f := by + classical + rw [map_sum] + have ht : ∀ ρ, coeff p ((X ρ : JetRing) • pderiv ℂ ρ f) = (p ρ : ℂ) * coeff p f := by + intro ρ + rw [coeff_X_smul] + by_cases h : Finsupp.single ρ 1 ≤ p + · have hρ : 1 ≤ p ρ := by simpa using Finsupp.single_le_iff.mp h + rw [if_pos h, coeff_pderiv, tsub_add_cancel_of_le h, Finsupp.coe_tsub, Pi.sub_apply, + Finsupp.single_eq_same, Nat.cast_sub hρ] + push_cast + ring + · have hρ : p ρ = 0 := by + by_contra hc + exact h (Finsupp.single_le_iff.mpr (by omega)) + rw [if_neg h, hρ] + simp + rw [Finset.sum_congr rfl fun ρ _ => ht ρ, ← Finset.sum_mul, ← Nat.cast_sum, + ← Finsupp.degree_eq_sum] + +/-- The scalar vanishing principle for the Euler operator: a jet vanishing at the base + point that is killed by the Euler operator is zero. -/ +lemma eq_zero_of_sum_X_smul_pderiv_eq_zero {f : JetRing} (h0 : constantCoeff f = 0) + (hf : ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ f = 0) : f = 0 := by + ext p + rcases eq_or_ne p 0 with rfl | hp + · simpa [coeff_zero_eq_constantCoeff] using h0 + · have h := congrArg (coeff p) hf + rw [coeff_sum_X_smul_pderiv, map_zero] at h + have hne : ((Finsupp.degree p : ℕ) : ℂ) ≠ 0 := + Nat.cast_ne_zero.mpr fun hc => hp ((Finsupp.degree_eq_zero_iff p).mp hc) + simpa using (mul_eq_zero.mp h).resolve_left hne + +/-! + +## Multiset derivative bookkeeping + +-/ + +/-- The base-point value of an iterated formal derivative is the corresponding Taylor + coefficient with the factorial normalization. -/ +lemma constantCoeff_foldl_pderiv (s : Multiset (Fin 1 ⊕ Fin 3)) (f : JetRing) : + constantCoeff (s.foldl (fun f ρ => pderiv ℂ ρ f) f) = + ((∏ ν, Nat.factorial (s.count ν) : ℕ) : ℂ) * coeff s.toFinsupp f := by + induction s using Multiset.induction_on generalizing f with + | empty => simp [coeff_zero_eq_constantCoeff] + | cons a t ih => + rw [Multiset.foldl_cons, ih, coeff_pderiv] + have hfin : (a ::ₘ t).toFinsupp = t.toFinsupp + Finsupp.single a 1 := by + rw [show (a ::ₘ t : Multiset (Fin 1 ⊕ Fin 3)) = {a} + t from + (Multiset.singleton_add a t).symm, map_add, Multiset.toFinsupp_singleton, add_comm] + have hfac : (∏ ν, Nat.factorial ((a ::ₘ t).count ν) : ℕ) = + (t.count a + 1) * ∏ ν, Nat.factorial (t.count ν) := by + rw [show (∏ ν, Nat.factorial ((a ::ₘ t).count ν) : ℕ) = + ∏ ν, ((if ν = a then t.count a + 1 else 1) * Nat.factorial (t.count ν)) from + Finset.prod_congr rfl fun ν _ => by + rcases eq_or_ne ν a with rfl | h + · rw [Multiset.count_cons_self, Nat.factorial_succ, if_pos rfl] + · rw [Multiset.count_cons_of_ne h, if_neg h, one_mul], + Finset.prod_mul_distrib, Finset.prod_ite_eq' Finset.univ a] + simp + rw [hfin, hfac, Multiset.toFinsupp_apply] + push_cast + ring + +/-- The key combinatorial identity behind the symmetrized Maurer–Cartan data: the sum + over a multiset `r` of base-point values of iterated derivatives of `g` in the + complementary directions is, up to factorials, the Taylor coefficient at `r` of the + radial contraction `∑ μ x_μ g_μ`. -/ +lemma sum_constantCoeff_foldl_erase (g : (Fin 1 ⊕ Fin 3) → JetRing) + (r : Multiset (Fin 1 ⊕ Fin 3)) : + (r.map fun μ => constantCoeff ((r.erase μ).foldl (fun f ρ => pderiv ℂ ρ f) (g μ))).sum = + ((∏ ν, Nat.factorial (r.count ν) : ℕ) : ℂ) * + coeff r.toFinsupp (∑ μ, (X μ : JetRing) • g μ) := by + classical + rw [Finset.sum_multiset_map_count, + Finset.sum_subset (Finset.subset_univ r.toFinset) (fun x _ hx => by + rw [Multiset.count_eq_zero.mpr fun hmem => hx (Multiset.mem_toFinset.mpr hmem), + zero_smul]), + map_sum, Finset.mul_sum] + refine Finset.sum_congr rfl fun μ _ => ?_ + rw [coeff_X_smul, constantCoeff_foldl_pderiv] + by_cases hμ : μ ∈ r + · rw [if_pos (Finsupp.single_le_iff.mpr (by + rw [Multiset.toFinsupp_apply] + exact Multiset.one_le_count_iff_mem.mpr hμ))] + have herase : (r.erase μ).toFinsupp = r.toFinsupp - Finsupp.single μ 1 := by + ext ν + rw [Multiset.toFinsupp_apply, Finsupp.coe_tsub, Pi.sub_apply, Multiset.toFinsupp_apply, + Finsupp.single_apply] + rcases eq_or_ne μ ν with rfl | h + · rw [Multiset.count_erase_self, if_pos rfl] + · rw [Multiset.count_erase_of_ne h.symm, if_neg h, Nat.sub_zero] + have hfac : r.count μ * ∏ ν, Nat.factorial ((r.erase μ).count ν) = + ∏ ν, Nat.factorial (r.count ν) := by + rw [← Finset.mul_prod_erase Finset.univ + (fun ν => Nat.factorial ((r.erase μ).count ν)) (Finset.mem_univ μ), + ← Finset.mul_prod_erase Finset.univ + (fun ν => Nat.factorial (r.count ν)) (Finset.mem_univ μ), + Multiset.count_erase_self, + Finset.prod_congr rfl fun ν hν => + congrArg Nat.factorial + (Multiset.count_erase_of_ne (Finset.mem_erase.mp hν).1 r), + ← mul_assoc, Nat.mul_factorial_pred (Multiset.count_pos.mpr hμ).ne'] + rw [herase, nsmul_eq_mul, ← mul_assoc, ← Nat.cast_mul, hfac] + · rw [if_neg fun hle => hμ (Multiset.one_le_count_iff_mem.mp (by + simpa [Multiset.toFinsupp_apply] using Finsupp.single_le_iff.mp hle)), + mul_zero, Multiset.count_eq_zero.mpr hμ, zero_smul] + +lemma degree_toFinsupp_eq_card (r : Multiset (Fin 1 ⊕ Fin 3)) : + Finsupp.degree (Multiset.toFinsupp r) = Multiset.card r := by + rw [Finsupp.degree_eq_sum, Finset.sum_congr rfl fun ν _ => Multiset.toFinsupp_apply r ν, + ← Finset.sum_subset (Finset.subset_univ r.toFinset) (fun x _ hx => + Multiset.count_eq_zero.mpr fun hmem => hx (Multiset.mem_toFinset.mpr hmem)), + Multiset.toFinset_sum_count_eq] + +end JetRing diff --git a/Physlib/Relativity/JetRing/Matrix.lean b/Physlib/Relativity/JetRing/Matrix.lean new file mode 100644 index 000000000..0efbccab6 --- /dev/null +++ b/Physlib/Relativity/JetRing/Matrix.lean @@ -0,0 +1,475 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.JetRing.Basic +public import Mathlib.LinearAlgebra.Matrix.Determinant.Basic +public import Mathlib.LinearAlgebra.Matrix.Adjugate +public import Mathlib.LinearAlgebra.Matrix.Trace +/-! +# Matrices over the jet ring + +Results about matrices with entries in `JetRing`: entrywise truncation of matrix +products, and the formal Frobenius theorem (parallel transport): a flat family of +matrices is the logarithmic derivative of a formal fundamental solution. +-/ + +@[expose] public section + +namespace JetRing + +open MvPowerSeries + +/-- Entrywise truncation of a matrix product only sees the factors through their + entrywise truncations. -/ +lemma matrix_truncation_mul {κ : Type} [Fintype κ] [DecidableEq κ] (n : ℕ) + (A B : Matrix κ κ JetRing) : + (A * B).map (truncation n) = + (A.map (truncation n) * B.map (truncation n)).map (truncation n) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply] + rw [truncation_sum, truncation_sum] + exact Finset.sum_congr rfl fun k _ => truncation_mul n _ _ + +/-- The congruence principle for entrywise-truncated matrix products. -/ +lemma matrix_truncation_mul_congr {κ : Type} [Fintype κ] [DecidableEq κ] {n : ℕ} + {A A' B B' : Matrix κ κ JetRing} + (hA : A.map (truncation n) = A'.map (truncation n)) + (hB : B.map (truncation n) = B'.map (truncation n)) : + (A * B).map (truncation n) = (A' * B').map (truncation n) := by + rw [matrix_truncation_mul, hA, hB, ← matrix_truncation_mul] + +lemma matrix_truncation_star {κ : Type} [Fintype κ] [DecidableEq κ] (n : ℕ) + (A : Matrix κ κ JetRing) : + (star A).map (truncation n) = star (A.map (truncation n)) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.star_apply] + exact truncation_star n (A j i) +/-! + +### Parallel transport + +The formal Frobenius theorem for the jet ring: a flat family of matrices `A_μ` is +the logarithmic derivative `(∂_μ F) F⁻¹` of a formal fundamental solution `F`, +unique once its value at the base point is fixed. Uniqueness is the vanishing +principle for first-order linear systems; existence is the Euler (radial) +recursion, with flatness entering to make the radial solution solve every +direction. + +-/ + + +/-- A flat gauge field is pure gauge, at the level of jets: if `A_μ` has vanishing + field strength, `∂_μ A_ν − ∂_ν A_μ − [A_μ, A_ν] = 0`, then `A_μ = (∂_μ F) F⁻¹` + for a Wilson line `F` based at the identity: `∂_μ F = A_μ F` with `F(0) = 1`. + Here a Wilson line means the parallel transport of `A` from the base point — + the path-ordered exponential `P exp(∫ A_μ dx^μ)`, path-independent since `A` is + flat. `F` is built order-by-order in its Taylor expansion; it is unique by + `JetRing.matrix_eq_zero_of_pderiv_eq_mul_add_mul`. -/ +lemma exists_parallelTransport {κ : Type} [Fintype κ] [DecidableEq κ] + (A : (Fin 1 ⊕ Fin 3) → Matrix κ κ JetRing) + (hA : ∀ μ ν, (A ν).map (pderiv ℂ μ) - (A μ).map (pderiv ℂ ν) = + A μ * A ν - A ν * A μ) : + ∃ F : Matrix κ κ JetRing, (constantCoeff : JetRing →+* ℂ).mapMatrix F = 1 ∧ + ∀ μ, F.map (pderiv ℂ μ) = A μ * F := by + open Finsupp Finset in + set B : Matrix κ κ JetRing := ∑ ρ, (X ρ : JetRing) • A ρ with hB + have hBlow : ∀ (M N : Matrix κ κ JetRing) p, (∀ i j q, degree q < degree p → + coeff q (M i j) = coeff q (N i j)) → + ∀ i j, coeff p ((B * M) i j) = coeff p ((B * N) i j) := fun M N p h i j => by + simp only [Matrix.mul_apply, map_sum, coeff_mul] + refine Finset.sum_congr rfl fun k _ => Finset.sum_congr rfl fun q hq => ?_ + rcases eq_or_ne q.1 0 with h1 | h1 + · rw [h1, coeff_zero_eq_constantCoeff, show constantCoeff (B i k) = 0 from by + simp [hB, Matrix.sum_apply, Matrix.smul_apply, smul_eq_mul, constantCoeff_X], + zero_mul, zero_mul] + · have h4 : degree q.1 + degree q.2 = degree p := by rw [← map_add, mem_antidiagonal.mp hq] + have h3 := Nat.pos_of_ne_zero fun hc => h1 ((degree_eq_zero_iff _).mp hc) + rw [h _ _ _ (by omega)] + set T : Matrix κ κ JetRing → Matrix κ κ JetRing := fun M => 1 + (B * M).map fun f => + show JetRing from fun m => if m = 0 then 0 else ((degree m : ℕ) : ℂ)⁻¹ * f m with hT + set F : Matrix κ κ JetRing := + Matrix.of fun i j => show JetRing from fun m => (T^[degree m + 1] 1) i j m with hFd + have hFco : ∀ p i j, coeff p (F i j) = coeff p ((T^[degree p + 1] 1) i j) := fun _ _ _ => rfl + have hTco : ∀ (M : Matrix κ κ JetRing) i j p, + coeff p ((T M) i j) = coeff p ((1 : Matrix κ κ JetRing) i j) + + if p = 0 then 0 else ((degree p : ℕ) : ℂ)⁻¹ * coeff p ((B * M) i j) := + fun M i j p => by simp only [hT]; rw [Matrix.add_apply, map_add, Matrix.map_apply]; rfl + have hmain : ∀ n p, degree p = n → ∀ k, n < k → ∀ i j, + coeff p ((T^[k] 1) i j) = coeff p ((T F) i j) := fun n => by + induction n using Nat.strong_induction_on with + | _ n ih => + intro p hp k hk i j; obtain ⟨k, rfl⟩ : ∃ k', k = k' + 1 := ⟨k - 1, by omega⟩ + rw [Function.iterate_succ_apply', hTco, hTco]; rcases eq_or_ne p 0 with h0 | h0 + · rw [if_pos h0, if_pos h0] + · rw [if_neg h0, if_neg h0, hBlow _ F _ (fun i' j' q hq => ?_) i j] + rw [hFco, ih (degree q) (hp ▸ hq) q rfl k (by omega) i' j', + ih (degree q) (hp ▸ hq) q rfl (degree q + 1) (by omega) i' j'] + have hkey := fun p (i j : κ) => (hFco p i j).trans (hmain _ p rfl _ (Nat.lt_succ_self _) i j) + have hFone : (constantCoeff : JetRing →+* ℂ).mapMatrix F = 1 := by + ext i j; simpa [hTco, Matrix.one_apply, apply_ite, coeff_one] using hkey 0 i j + have hEco : ∀ (M : Matrix κ κ JetRing) p i j, + coeff p ((∑ ρ, (X ρ : JetRing) • M.map (pderiv ℂ ρ)) i j) = + ((degree p : ℕ) : ℂ) * coeff p (M i j) := fun M p i j => by + have ht : ∀ ρ, coeff p (((X ρ : JetRing) • M.map (pderiv ℂ ρ)) i j) = + (p ρ : ℂ) * coeff p (M i j) := fun ρ => by + rw [Matrix.smul_apply, Matrix.map_apply, smul_eq_mul, + show (X ρ : JetRing) = monomial (single ρ 1) 1 from rfl, coeff_monomial_mul] + by_cases h : single ρ 1 ≤ p + · have hρ : 1 ≤ p ρ := by simpa using single_le_iff.mp h + rw [if_pos h, one_mul, coeff_pderiv, tsub_add_cancel_of_le h, tsub_apply, + single_eq_same, Nat.cast_sub hρ]; push_cast; ring + · have hρ : p ρ = 0 := by by_contra hc; exact h (single_le_iff.mpr (by omega)) + rw [if_neg h, hρ]; simp + rw [Matrix.sum_apply, map_sum, Finset.sum_congr rfl fun ρ _ => ht ρ, ← Finset.sum_mul, + ← Nat.cast_sum, ← degree_eq_sum] + have hleib : ∀ ρ (M N : Matrix κ κ JetRing), (M * N).map (pderiv ℂ ρ) = + M.map (pderiv ℂ ρ) * N + M * N.map (pderiv ℂ ρ) := fun ρ M N => by + ext i j : 1; simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans sum_add_distrib + set G := fun ν : Fin 1 ⊕ Fin 3 => F.map (pderiv ℂ ν) - A ν * F with hG + have hstar : ∀ μ ν, (G ν).map (pderiv ℂ μ) = + (G μ).map (pderiv ℂ ν) + (A μ * G ν - A ν * G μ) := fun μ ν => by + have hcm : ∀ (M : Matrix κ κ JetRing), (M.map (pderiv ℂ ν)).map (pderiv ℂ μ) = + (M.map (pderiv ℂ μ)).map (pderiv ℂ ν) := + fun M => Matrix.ext fun _ _ => pderiv_comm _ _ _ + simp only [hG] + rw [Matrix.map_sub _ (fun a b => map_sub _ a b), Matrix.map_sub _ (fun a b => map_sub _ a b), + hcm, hleib μ (A ν) F, hleib ν (A μ) F, sub_eq_iff_eq_add.mp (hA μ ν)] + noncomm_ring + have hG0 : (∑ ρ, (X ρ : JetRing) • G ρ) = 0 := by + have h1 : (∑ ρ, (X ρ : JetRing) • G ρ) = + (∑ ρ, (X ρ : JetRing) • F.map (pderiv ℂ ρ)) - B * F := by + rw [hB, Finset.sum_mul, ← sum_sub_distrib] + exact Finset.sum_congr rfl fun ρ _ => by rw [hG]; rw [smul_sub, Matrix.smul_mul] + rw [h1, sub_eq_zero]; ext i j : 1; ext p; rw [hEco] + rcases eq_or_ne p 0 with rfl | h0 + · have h := hBlow F 0 0 (fun _ _ q hq => absurd hq (by simp)) i j + simp only [mul_zero, Matrix.zero_apply, map_zero] at h; simp [h] + · rw [hkey p i j, hTco, show coeff p ((1 : Matrix κ κ JetRing) i j) = 0 from by + simp [Matrix.one_apply, apply_ite, coeff_one, h0], zero_add, if_neg h0, ← mul_assoc, + mul_inv_cancel₀ (Nat.cast_ne_zero.mpr fun hc => h0 ((degree_eq_zero_iff p).mp hc)), + one_mul] + have hS2 : ∀ ν, (∑ ρ, (X ρ : JetRing) • (G ρ).map (pderiv ℂ ν)) = - G ν := by + intro ν + have hmap : ((∑ ρ, (X ρ : JetRing) • G ρ).map (pderiv ℂ ν)) = + G ν + ∑ ρ, (X ρ : JetRing) • (G ρ).map (pderiv ℂ ν) := by + ext i j : 1; simp only [Matrix.map_apply, Matrix.sum_apply, Matrix.smul_apply, + smul_eq_mul, map_sum, Derivation.leibniz, Matrix.add_apply] + rw [sum_add_distrib, sum_eq_single_of_mem (f := fun ρ => G ρ i j * pderiv ℂ ν (X ρ)) + ν (mem_univ ν) fun b _ hb => by rw [pderiv_X_of_ne hb, mul_zero]] + rw [pderiv_X_self, mul_one]; exact add_comm _ _ + rw [hG0, Matrix.map_zero _ (map_zero _)] at hmap + exact eq_neg_of_add_eq_zero_right hmap.symm + have halg : ∀ ν p i j, + (((degree p : ℕ) : ℂ) + 1) * coeff p (G ν i j) = coeff p ((B * G ν) i j) := by + intro ν p i j; have hs1 : (∑ ρ, (X ρ : JetRing) • (G ν).map (pderiv ℂ ρ)) = + (∑ ρ, (X ρ : JetRing) • (G ρ).map (pderiv ℂ ν)) + + (B * G ν - A ν * ∑ ρ, (X ρ : JetRing) • G ρ) := by + rw [Finset.sum_congr rfl fun ρ _ => congrArg ((X ρ : JetRing) • ·) (hstar ρ ν)] + simp only [smul_add, smul_sub, sum_add_distrib, sum_sub_distrib] + congr 1; congr 1 + · rw [hB, Finset.sum_mul]; exact Finset.sum_congr rfl fun _ _ => (Matrix.smul_mul _ _ _).symm + · rw [Finset.mul_sum]; exact Finset.sum_congr rfl fun _ _ => (Matrix.mul_smul _ _ _).symm + rw [hG0, mul_zero, sub_zero, hS2] at hs1 + have h := congrArg (fun M => coeff p (M i j)) hs1 + simp only [Matrix.add_apply, Matrix.neg_apply, map_add, map_neg] at h + rw [hEco] at h; linear_combination h + have hzero : ∀ ν, G ν = 0 := fun ν => by + have hm : ∀ n q, degree q = n → ∀ i j, coeff q (G ν i j) = 0 := fun n => by + induction n using Nat.strong_induction_on with + | _ n ih => + intro q hq i j; have h := halg ν q i j + rw [hBlow (G ν) 0 q (fun i' j' r hr => by + rw [ih (degree r) (hq ▸ hr) r rfl i' j', Matrix.zero_apply, map_zero]) i j, + mul_zero] at h + simp only [Matrix.zero_apply, map_zero] at h + exact (mul_eq_zero.mp h).resolve_left (by exact_mod_cast Nat.succ_ne_zero (degree q)) + ext i j : 1; ext p; rw [hm (degree p) p rfl i j, Matrix.zero_apply, map_zero] + exact ⟨F, hFone, fun ν => sub_eq_zero.mp (hzero ν)⟩ + + +/-! + +## The Euler operator toolkit on matrices + +-/ + +/-- Entrywise evaluation at the base point commutes with the conjugate transpose. -/ +lemma mapMatrix_constantCoeff_star {n : Type} [Fintype n] [DecidableEq n] + (A : Matrix n n JetRing) : + (constantCoeff : JetRing →+* ℂ).mapMatrix (star A) = + star ((constantCoeff : JetRing →+* ℂ).mapMatrix A) := by + ext i j + simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.star_apply] + +/-- The Euler operator on matrices of jets acts entrywise on Taylor coefficients as + multiplication by the total degree. -/ +lemma coeff_sum_X_smul_map_pderiv {κ : Type} [Fintype κ] [DecidableEq κ] + (M : Matrix κ κ JetRing) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) (i j : κ) : + coeff p ((∑ ρ, (X ρ : JetRing) • M.map (pderiv ℂ ρ)) i j) = + ((Finsupp.degree p : ℕ) : ℂ) * coeff p (M i j) := by + rw [show (∑ ρ, (X ρ : JetRing) • M.map (pderiv ℂ ρ)) i j + = ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ (M i j) from by + rw [Matrix.sum_apply] + exact Finset.sum_congr rfl fun ρ _ => rfl] + exact coeff_sum_X_smul_pderiv (M i j) p + +/-- The vanishing principle for the Euler operator: a matrix of jets vanishing at the + base point and satisfying `E W = A W + W B` with `A`, `B` vanishing at the base point + is zero. Each Taylor coefficient of `W` is a multiple of coefficients of strictly + smaller degree, so all vanish by strong induction on the degree. -/ +lemma matrix_eq_zero_of_euler_eq_mul_add_mul {κ : Type} [Fintype κ] [DecidableEq κ] + {W : Matrix κ κ JetRing} (A B : Matrix κ κ JetRing) + (hA : ∀ i j, constantCoeff (A i j) = 0) (hB : ∀ i j, constantCoeff (B i j) = 0) + (h0 : ∀ i j, constantCoeff (W i j) = 0) + (hW : ∑ ρ, (X ρ : JetRing) • W.map (pderiv ℂ ρ) = A * W + W * B) : + W = 0 := by + classical + have hlow : ∀ p : (Fin 1 ⊕ Fin 3) →₀ ℕ, + (∀ (i : κ) (j : κ) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), + Finsupp.degree q < Finsupp.degree p → coeff q (W i j) = 0) → + ∀ i j, coeff p ((A * W + W * B) i j) = 0 := by + intro p hp i j + have hAW : coeff p ((A * W) i j) = 0 := by + rw [Matrix.mul_apply, map_sum] + refine Finset.sum_eq_zero fun k _ => ?_ + rw [coeff_mul] + refine Finset.sum_eq_zero fun q hq => ?_ + rcases eq_or_ne q.1 0 with h1 | h1 + · rw [h1, coeff_zero_eq_constantCoeff, hA, zero_mul] + · have h4 : Finsupp.degree q.1 + Finsupp.degree q.2 = Finsupp.degree p := by + rw [← map_add, Finset.mem_antidiagonal.mp hq] + have h3 := Nat.pos_of_ne_zero fun hc => h1 ((Finsupp.degree_eq_zero_iff _).mp hc) + rw [hp _ _ q.2 (by omega), mul_zero] + have hWB : coeff p ((W * B) i j) = 0 := by + rw [Matrix.mul_apply, map_sum] + refine Finset.sum_eq_zero fun k _ => ?_ + rw [coeff_mul] + refine Finset.sum_eq_zero fun q hq => ?_ + rcases eq_or_ne q.2 0 with h1 | h1 + · rw [h1, coeff_zero_eq_constantCoeff, hB, mul_zero] + · have h4 : Finsupp.degree q.1 + Finsupp.degree q.2 = Finsupp.degree p := by + rw [← map_add, Finset.mem_antidiagonal.mp hq] + have h3 := Nat.pos_of_ne_zero fun hc => h1 ((Finsupp.degree_eq_zero_iff _).mp hc) + rw [hp _ _ q.1 (by omega), zero_mul] + rw [Matrix.add_apply, map_add, hAW, hWB, add_zero] + have hm : ∀ (n : ℕ) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree p = n → + ∀ i j, coeff p (W i j) = 0 := by + intro n + induction n using Nat.strong_induction_on with + | _ n ih => + intro p hp i j + rcases Nat.eq_zero_or_pos n with hn | hn + · have hp0 : p = 0 := (Finsupp.degree_eq_zero_iff _).mp (by omega) + rw [hp0, coeff_zero_eq_constantCoeff] + exact h0 i j + · have h : coeff p ((∑ ρ, (X ρ : JetRing) • W.map (pderiv ℂ ρ)) i j) = + coeff p ((A * W + W * B) i j) := congrArg (fun M => coeff p (M i j)) hW + rw [coeff_sum_X_smul_map_pderiv, + hlow p (fun i' j' q hq => ih (Finsupp.degree q) (by omega) q rfl i' j') i j] at h + have hne : ((Finsupp.degree p : ℕ) : ℂ) ≠ 0 := by + rw [hp] + exact_mod_cast hn.ne' + exact (mul_eq_zero.mp h).resolve_left hne + ext i j : 1 + ext p + rw [hm (Finsupp.degree p) p rfl i j] + simp + +/-- The Euler (radial) transport of a jet matrix `R` vanishing at the base point: + a fundamental solution of the radial system `E U = R U` based at the identity, + built order-by-order by the Euler recursion. -/ +lemma exists_matrix_eulerTransport {κ : Type} [Fintype κ] [DecidableEq κ] + (R : Matrix κ κ JetRing) (hR0 : ∀ i j, constantCoeff (R i j) = 0) : + ∃ U : Matrix κ κ JetRing, (constantCoeff : JetRing →+* ℂ).mapMatrix U = 1 ∧ + ∑ ρ, (X ρ : JetRing) • U.map (pderiv ℂ ρ) = R * U := by + classical + have hRlow : ∀ (M N : Matrix κ κ JetRing) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), + (∀ (i : κ) (j : κ) (q : (Fin 1 ⊕ Fin 3) →₀ ℕ), + Finsupp.degree q < Finsupp.degree p → coeff q (M i j) = coeff q (N i j)) → + ∀ i j, coeff p ((R * M) i j) = coeff p ((R * N) i j) := fun M N p h i j => by + simp only [Matrix.mul_apply, map_sum, coeff_mul] + refine Finset.sum_congr rfl fun k _ => Finset.sum_congr rfl fun q hq => ?_ + rcases eq_or_ne q.1 0 with h1 | h1 + · rw [h1, coeff_zero_eq_constantCoeff, hR0, zero_mul, zero_mul] + · have h4 : Finsupp.degree q.1 + Finsupp.degree q.2 = Finsupp.degree p := by + rw [← map_add, Finset.mem_antidiagonal.mp hq] + have h3 := Nat.pos_of_ne_zero fun hc => h1 ((Finsupp.degree_eq_zero_iff _).mp hc) + rw [h _ _ _ (by omega)] + set T : Matrix κ κ JetRing → Matrix κ κ JetRing := fun M => 1 + (R * M).map fun f => + show JetRing from fun m => if m = 0 then 0 else ((Finsupp.degree m : ℕ) : ℂ)⁻¹ * f m + with hT + set U : Matrix κ κ JetRing := + Matrix.of fun i j => show JetRing from fun m => (T^[Finsupp.degree m + 1] 1) i j m with hUd + have hUco : ∀ (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) i j, + coeff p (U i j) = coeff p ((T^[Finsupp.degree p + 1] 1) i j) := fun _ _ _ => rfl + have hTco : ∀ (M : Matrix κ κ JetRing) i j (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), + coeff p ((T M) i j) = coeff p ((1 : Matrix κ κ JetRing) i j) + + if p = 0 then 0 else ((Finsupp.degree p : ℕ) : ℂ)⁻¹ * coeff p ((R * M) i j) := + fun M i j p => by + simp only [hT] + rw [Matrix.add_apply, map_add, Matrix.map_apply] + rfl + have hmain : ∀ (n : ℕ) (p : (Fin 1 ⊕ Fin 3) →₀ ℕ), Finsupp.degree p = n → ∀ k, n < k → + ∀ i j, coeff p ((T^[k] 1) i j) = coeff p ((T U) i j) := fun n => by + induction n using Nat.strong_induction_on with + | _ n ih => + intro p hp k hk i j + obtain ⟨k, rfl⟩ : ∃ k', k = k' + 1 := ⟨k - 1, by omega⟩ + rw [Function.iterate_succ_apply', hTco, hTco] + rcases eq_or_ne p 0 with h0 | h0 + · rw [if_pos h0, if_pos h0] + · rw [if_neg h0, if_neg h0, hRlow _ U _ (fun i' j' q hq => ?_) i j] + rw [hUco, ih (Finsupp.degree q) (by omega) q rfl k (by omega) i' j', + ih (Finsupp.degree q) (by omega) q rfl (Finsupp.degree q + 1) (by omega) i' j'] + have hkey := fun (p : (Fin 1 ⊕ Fin 3) →₀ ℕ) (i j : κ) => + (hUco p i j).trans (hmain _ p rfl _ (Nat.lt_succ_self _) i j) + have hUone : (constantCoeff : JetRing →+* ℂ).mapMatrix U = 1 := by + ext i j + simpa [hTco, Matrix.one_apply, apply_ite, coeff_one] using hkey 0 i j + refine ⟨U, hUone, ?_⟩ + ext i j : 1 + ext p + rw [coeff_sum_X_smul_map_pderiv] + rcases eq_or_ne p 0 with rfl | h0 + · rw [show ((Finsupp.degree (0 : (Fin 1 ⊕ Fin 3) →₀ ℕ) : ℕ) : ℂ) = 0 by simp, zero_mul] + rw [Matrix.mul_apply, map_sum] + exact (Finset.sum_eq_zero fun k _ => by + rw [coeff_zero_eq_constantCoeff, map_mul, hR0, zero_mul]).symm + · rw [hkey p i j, hTco, show coeff p ((1 : Matrix κ κ JetRing) i j) = 0 from by + simp [Matrix.one_apply, apply_ite, coeff_one, h0], zero_add, if_neg h0, ← mul_assoc, + mul_inv_cancel₀ (Nat.cast_ne_zero.mpr fun hc => h0 ((Finsupp.degree_eq_zero_iff p).mp hc)), + one_mul] + +/-! + +## Unitarity and determinant of the Euler transport + +-/ + +/-- The entrywise Leibniz rule for matrix products of jets. -/ +lemma matrix_map_pderiv_mul {κ : Type} [Fintype κ] [DecidableEq κ] (ρ : Fin 1 ⊕ Fin 3) + (M N : Matrix κ κ JetRing) : + (M * N).map (pderiv ℂ ρ) = M.map (pderiv ℂ ρ) * N + M * N.map (pderiv ℂ ρ) := by + ext i j : 1 + simp only [Matrix.map_apply, Matrix.mul_apply, Matrix.add_apply, map_sum, + Derivation.leibniz, smul_eq_mul] + exact (Finset.sum_congr rfl fun k _ => by ring).trans Finset.sum_add_distrib + +/-- The Euler operator on matrices of jets is a derivation. -/ +lemma sum_X_smul_map_pderiv_mul {κ : Type} [Fintype κ] [DecidableEq κ] + (M N : Matrix κ κ JetRing) : + ∑ ρ, (X ρ : JetRing) • (M * N).map (pderiv ℂ ρ) = + (∑ ρ, (X ρ : JetRing) • M.map (pderiv ℂ ρ)) * N + + M * ∑ ρ, (X ρ : JetRing) • N.map (pderiv ℂ ρ) := by + rw [Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun ρ _ => ?_ + rw [matrix_map_pderiv_mul, smul_add, Matrix.smul_mul, Matrix.mul_smul] + +/-- The Euler operator commutes with the conjugate transpose. -/ +lemma sum_X_smul_map_pderiv_star {κ : Type} [Fintype κ] [DecidableEq κ] + (M : Matrix κ κ JetRing) : + ∑ ρ, (X ρ : JetRing) • (star M).map (pderiv ℂ ρ) = + star (∑ ρ, (X ρ : JetRing) • M.map (pderiv ℂ ρ)) := by + ext i j : 1 + simp only [Matrix.sum_apply, Matrix.star_apply, Matrix.smul_apply, Matrix.map_apply, + smul_eq_mul, star_sum, star_mul', star_X, ← JetRing.pderiv_star] + +/-- The Euler operator kills the identity matrix. -/ +lemma sum_X_smul_map_pderiv_one {κ : Type} [Fintype κ] [DecidableEq κ] : + ∑ ρ, (X ρ : JetRing) • (1 : Matrix κ κ JetRing).map (pderiv ℂ ρ) = 0 := by + refine Finset.sum_eq_zero fun ρ _ => ?_ + rw [show (1 : Matrix κ κ JetRing).map (pderiv ℂ ρ) = 0 from Matrix.ext fun i j => by + simp [Matrix.map_apply, Matrix.one_apply, apply_ite (pderiv ℂ ρ)], smul_zero] + +/-- A fundamental solution of the radial system `E U = R U` based at the identity is + unitary when `R` is anti-hermitian: `U U† − 1` vanishes at the base point and + satisfies a homogeneous linear radial system, so it vanishes identically. -/ +lemma eulerTransport_mul_star {κ : Type} [Fintype κ] [DecidableEq κ] + {R U : Matrix κ κ JetRing} (hRstar : star R = -R) + (hR0 : ∀ i j, constantCoeff (R i j) = 0) + (hU0 : (constantCoeff : JetRing →+* ℂ).mapMatrix U = 1) + (hEU : ∑ ρ, (X ρ : JetRing) • U.map (pderiv ℂ ρ) = R * U) : + U * star U = 1 := by + have hEstar : ∑ ρ, (X ρ : JetRing) • (star U).map (pderiv ℂ ρ) = -(star U * R) := by + rw [sum_X_smul_map_pderiv_star, hEU, star_mul, hRstar, Matrix.mul_neg] + have hW0 : (constantCoeff : JetRing →+* ℂ).mapMatrix (U * star U - 1) = 0 := by + rw [map_sub, map_mul, mapMatrix_constantCoeff_star, hU0, star_one, + mul_one, map_one, sub_self] + have h0 : ∀ i j, constantCoeff ((U * star U - 1) i j) = 0 := fun i j => by + simpa [RingHom.mapMatrix_apply, Matrix.map_apply] using congrArg (fun M => M i j) hW0 + have hB : ∀ i j, constantCoeff ((-R) i j) = 0 := fun i j => by + simp [hR0 i j] + have hEW : ∑ ρ, (X ρ : JetRing) • (U * star U - 1).map (pderiv ℂ ρ) = + R * (U * star U - 1) + (U * star U - 1) * (-R) := by + have hsub : ∀ ρ : Fin 1 ⊕ Fin 3, (U * star U - 1).map (pderiv ℂ ρ) = + (U * star U).map (pderiv ℂ ρ) - (1 : Matrix κ κ JetRing).map (pderiv ℂ ρ) := + fun ρ => Matrix.ext fun i j => by simp [Matrix.map_apply] + simp only [hsub, smul_sub, Finset.sum_sub_distrib] + rw [sum_X_smul_map_pderiv_mul, hEU, hEstar, sum_X_smul_map_pderiv_one, sub_zero] + noncomm_ring + exact sub_eq_zero.mp (matrix_eq_zero_of_euler_eq_mul_add_mul R (-R) hR0 hB h0 hEW) + +/-- A fundamental solution of the radial system `E U = R U` based at the identity has + determinant one when `R` is traceless: by Jacobi's formula the determinant is killed + by the Euler operator, so it is the constant `1`. -/ +lemma eulerTransport_det {κ : Type} [Fintype κ] [DecidableEq κ] + {R U : Matrix κ κ JetRing} + (hjac : ∀ (M : Matrix κ κ JetRing) (μ : Fin 1 ⊕ Fin 3), + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace) + (hRtr : R.trace = 0) + (hU0 : (constantCoeff : JetRing →+* ℂ).mapMatrix U = 1) + (hEU : ∑ ρ, (X ρ : JetRing) • U.map (pderiv ℂ ρ) = R * U) : + U.det = 1 := by + have hEdet : ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ U.det = 0 := by + calc ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ U.det + = ∑ ρ, (X ρ : JetRing) • (U.map (pderiv ℂ ρ) * U.adjugate).trace := by + exact Finset.sum_congr rfl fun ρ _ => by rw [hjac] + _ = ((∑ ρ, (X ρ : JetRing) • U.map (pderiv ℂ ρ)) * U.adjugate).trace := by + rw [Finset.sum_mul, Matrix.trace_sum] + exact Finset.sum_congr rfl fun ρ _ => by + rw [Matrix.smul_mul, Matrix.trace_smul] + _ = (R * (U.det • (1 : Matrix κ κ JetRing))).trace := by + rw [hEU, Matrix.mul_assoc, Matrix.mul_adjugate] + _ = 0 := by + rw [mul_smul_comm, mul_one, Matrix.trace_smul, hRtr, smul_zero] + have hd0 : constantCoeff (U.det - 1) = 0 := by + rw [map_sub, map_one, RingHom.map_det, hU0, Matrix.det_one, sub_self] + have hEd : ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ (U.det - 1) = 0 := by + calc ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ (U.det - 1) + = ∑ ρ, (X ρ : JetRing) • pderiv ℂ ρ U.det := by + exact Finset.sum_congr rfl fun ρ _ => by rw [map_sub, pderiv_one, sub_zero] + _ = 0 := hEdet + exact sub_eq_zero.mp (eq_zero_of_sum_X_smul_pderiv_eq_zero hd0 hEd) + +/-! + +## Jacobi's formula on the matrix factors, and degree bookkeeping + +-/ + +lemma jacobi_fin3 (M : Matrix (Fin 3) (Fin 3) JetRing) (μ : Fin 1 ⊕ Fin 3) : + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace := by + rw [Matrix.det_fin_three] + simp only [Matrix.trace_fin_three, Matrix.mul_apply, Fin.sum_univ_three, + Matrix.map_apply, Matrix.adjugate_fin_three, Matrix.of_apply, Matrix.cons_val', + Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, Matrix.head_cons, + Matrix.tail_cons, Matrix.head_fin_const, Matrix.empty_val', Matrix.cons_val_fin_one, + map_sub, map_add, Derivation.leibniz, smul_eq_mul] + ring + +lemma jacobi_fin2 (M : Matrix (Fin 2) (Fin 2) JetRing) (μ : Fin 1 ⊕ Fin 3) : + pderiv ℂ μ M.det = (M.map (pderiv ℂ μ) * M.adjugate).trace := by + rw [Matrix.det_fin_two] + simp only [Matrix.adjugate_fin_two, Matrix.trace_fin_two, Matrix.mul_apply, + Matrix.map_apply, Matrix.of_apply, Matrix.cons_val', Matrix.cons_val_zero, + Matrix.empty_val', Matrix.cons_val_fin_one, Fin.sum_univ_two, Matrix.cons_val_one, + map_sub, Derivation.leibniz, smul_eq_mul] + ring + +end JetRing diff --git a/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean b/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean new file mode 100644 index 000000000..7082cf047 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Boosts/Axis.lean @@ -0,0 +1,498 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.SL2C.AxisRotations +public import Physlib.Relativity.PauliMatrices.Basic +public import Physlib.Relativity.MinkowskiMatrix +/-! +# The boosts along the coordinate axes + +## i. Overview + +The one-parameter boosts `boostZel t`, `boostXel t`, `boostYel t` along the three coordinate +axes as elements of `SL(2,ℂ)`, their Lorentz matrices, their inverses, the uniform +parametrisation `boostAxis`, and the rotations conjugating the `z`-boost into the `x`- and +`y`-boosts. + +## ii. What they are for + +These are the boosts boost-weight gradings are defined by: an element of a representation has +boost weight `k` along an axis when the corresponding one-parameter family acts on it by +`t ^ k`. The conjugations `boostXel_eq_conj`, `boostYel_eq_conj` let facts proved for the +`z`-axis be transported to the other two. + +## iii. Key results + +- `Lorentz.boostZel`, `Lorentz.boostXel`, `Lorentz.boostYel` : the one-parameter boosts. +- `Lorentz.toLorentzGroup_boostZel` and its two companions : their Lorentz matrices. +- `Lorentz.boostAxis` : the boost along the `i`-th axis. +- `Lorentz.exists_conj_boostAxis` : every axis boost is a rotation of the `z`-boost. + +## iv. Table of contents + +- A. The boosts along the three axes +- B. Their Lorentz matrices +- C. Their inverses +- D. The uniform parametrisation and the conjugations + +-/ + +@[expose] public section + +open scoped minkowskiMatrix PauliMatrix +open Matrix MatrixGroups + +namespace Lorentz.SL2C + +/-- The `SL(2,ℂ)` lift of the boost along spatial axis `i`, with `0 = x`, `1 = y`, and +`2 = z`. The parameter `t` is multiplicative, and for `t > 0` the rapidity is `2 * log t`. -/ +noncomputable def boostAxis : Fin 3 → (t : ℝ) → t ≠ 0 → SL(2,ℂ) + | 0, t, ht => + ⟨!![((t : ℂ) + (t : ℂ)⁻¹) / 2, ((t : ℂ) - (t : ℂ)⁻¹) / 2; + ((t : ℂ) - (t : ℂ)⁻¹) / 2, ((t : ℂ) + (t : ℂ)⁻¹) / 2], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + rw [Matrix.det_fin_two_of] + field_simp + ring⟩ + | 1, t, ht => + ⟨!![((t : ℂ) + (t : ℂ)⁻¹) / 2, -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2; + Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2, ((t : ℂ) + (t : ℂ)⁻¹) / 2], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + have h2 : -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2 * + (Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2) = + ((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2) := by + have hI : -Complex.I * Complex.I = 1 := by + rw [neg_mul, Complex.I_mul_I, neg_neg] + calc -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2 * + (Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2) + = (-Complex.I * Complex.I) * + (((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2)) := by + ring + _ = ((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2) := by + rw [hI, one_mul] + rw [Matrix.det_fin_two_of, h2] + field_simp + ring⟩ + | 2, t, ht => + ⟨!![(t : ℂ), 0; 0, (t : ℂ)⁻¹], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + rw [Matrix.det_fin_two_of] + simp [mul_inv_cancel₀ htc]⟩ + +/-- The matrix entries of the `SL(2,ℂ)` boost lift along the `x`-axis. -/ +@[simp] lemma boostAxis_zero_apply (t : ℝ) (ht : t ≠ 0) (j k : Fin 2) : + (boostAxis 0 t ht).1 j k = + (!![((t : ℂ) + (t : ℂ)⁻¹) / 2, ((t : ℂ) - (t : ℂ)⁻¹) / 2; + ((t : ℂ) - (t : ℂ)⁻¹) / 2, ((t : ℂ) + (t : ℂ)⁻¹) / 2]) j k := rfl + +/-- The matrix entries of the `SL(2,ℂ)` boost lift along the `y`-axis. -/ +@[simp] lemma boostAxis_one_apply (t : ℝ) (ht : t ≠ 0) (j k : Fin 2) : + (boostAxis 1 t ht).1 j k = + (!![((t : ℂ) + (t : ℂ)⁻¹) / 2, + -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2; + Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2, + ((t : ℂ) + (t : ℂ)⁻¹) / 2]) j k := rfl + +/-- The matrix entries of the diagonal `SL(2,ℂ)` boost lift along the `z`-axis. -/ +@[simp] lemma boostAxis_two_apply (t : ℝ) (ht : t ≠ 0) (j k : Fin 2) : + (boostAxis 2 t ht).1 j k = (!![(t : ℂ), 0; 0, (t : ℂ)⁻¹]) j k := rfl + +/-- Inverting an axis boost replaces its multiplicative parameter `t` by `t⁻¹`. -/ +lemma boostAxis_inv (i : Fin 3) (t : ℝ) (ht : t ≠ 0) : + (boostAxis i t ht)⁻¹ = boostAxis i t⁻¹ (inv_ne_zero ht) := by + fin_cases i + · ext j k + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> + simp [boostAxis, Complex.ofReal_inv, inv_inv] <;> + ring + · ext j k + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> + simp [boostAxis, Complex.ofReal_inv, inv_inv] <;> + ring + · ext j k + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> + simp [boostAxis, Complex.ofReal_inv, inv_inv] + +/-- The matrix underlying an axis-boost lift is Hermitian. -/ +lemma boostAxis_conjTranspose (i : Fin 3) (t : ℝ) (ht : t ≠ 0) : + (boostAxis i t ht).1ᴴ = (boostAxis i t ht).1 := by + fin_cases i <;> ext j k <;> fin_cases j <;> fin_cases k <;> simp [boostAxis] + +/-- Every axis boost is obtained by conjugating the `z`-axis boost by `rotationZToAxis`. -/ +lemma boostAxis_eq_conj (i : Fin 3) (t : ℝ) (ht : t ≠ 0) : + boostAxis i t ht = + rotationZToAxis i * boostAxis 2 t ht * (rotationZToAxis i)⁻¹ := by + fin_cases i + · refine Subtype.ext ?_ + change !![((t : ℂ) + (t : ℂ)⁻¹) / 2, ((t : ℂ) - (t : ℂ)⁻¹) / 2; + ((t : ℂ) - (t : ℂ)⁻¹) / 2, ((t : ℂ) + (t : ℂ)⁻¹) / 2] = + (rotationZToAxis 0).1 * !![(t : ℂ), 0; 0, (t : ℂ)⁻¹] * + ((rotationZToAxis 0)⁻¹).1 + rw [rotationZToAxis_zero_mul_diagonal_mul_inv] + · refine Subtype.ext ?_ + change !![((t : ℂ) + (t : ℂ)⁻¹) / 2, + -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2; + Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2, + ((t : ℂ) + (t : ℂ)⁻¹) / 2] = + (rotationZToAxis 1).1 * !![(t : ℂ), 0; 0, (t : ℂ)⁻¹] * + ((rotationZToAxis 1)⁻¹).1 + rw [rotationZToAxis_one_mul_diagonal_mul_inv] + · refine Subtype.ext ?_ + change !![(t : ℂ), 0; 0, (t : ℂ)⁻¹] = + (rotationZToAxis 2).1 * !![(t : ℂ), 0; 0, (t : ℂ)⁻¹] * + ((rotationZToAxis 2)⁻¹).1 + rw [rotationZToAxis_two_mul_diagonal_mul_inv] + +/-- Every coordinate-axis boost is conjugate to the `z`-axis boost. -/ +lemma exists_conj_boostAxis (i : Fin 3) : + ∃ R : SL(2,ℂ), ∀ (t : ℝ) (ht : t ≠ 0), + boostAxis i t ht = R * boostAxis 2 t ht * R⁻¹ := by + exact ⟨rotationZToAxis i, fun t ht => boostAxis_eq_conj i t ht⟩ + +end Lorentz.SL2C + +namespace LorentzGroup + +/-- The Lorentz transformation induced by the multiplicatively parameterized `SL(2,ℂ)` boost +along spatial axis `i`. -/ +noncomputable def boostAxis (i : Fin 3) (t : ℝ) (ht : t ≠ 0) : LorentzGroup 3 := + Lorentz.SL2C.toLorentzGroup (Lorentz.SL2C.boostAxis i t ht) + +/-- The entries of an axis boost in the Lorentz group. -/ +lemma boostAxis_apply (i : Fin 3) (t : ℝ) (ht : t ≠ 0) (a b : Fin 1 ⊕ Fin 3) : + (boostAxis i t ht).1 a b = + if a = Sum.inl 0 ∧ b = Sum.inl 0 then (t ^ 2 + (t⁻¹) ^ 2) / 2 + else if a = Sum.inl 0 ∧ b = Sum.inr i then -((t ^ 2 - (t⁻¹) ^ 2) / 2) + else if a = Sum.inr i ∧ b = Sum.inl 0 then -((t ^ 2 - (t⁻¹) ^ 2) / 2) + else if a = Sum.inr i ∧ b = Sum.inr i then (t ^ 2 + (t⁻¹) ^ 2) / 2 + else if a = b then 1 else 0 := by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Complex.ofReal_injective ?_ + rw [boostAxis, Lorentz.SL2C.toLorentzGroup_eq_trace, + PauliMatrix.trace_pauliSelfAdjoint'_mul_apply, Lorentz.SL2C.boostAxis_conjTranspose] + fin_cases i + all_goals + rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + simp [Lorentz.SL2C.boostAxis, PauliMatrix.pauliSelfAdjoint', PauliMatrix.pauliMatrix, + Matrix.mul_apply, Fin.sum_univ_two] <;> + field_simp <;> + ring_nf + all_goals simp only [Complex.I_sq, Complex.I_pow_four] + all_goals ring + +end LorentzGroup + +set_option maxHeartbeats 1000000 + +namespace Lorentz + +open scoped minkowskiMatrix PauliMatrix +open Matrix MatrixGroups + +/-! + +## A. The boosts along the three axes + +The one-parameter families of boosts `diag(t, t⁻¹)` (along `z`) and their conjugates along `x` +and `y`. + +-/ + + +/-- The lift `diag(t, t⁻¹)` of the boost along the `z`-axis with rapidity + `2 log t`. -/ +noncomputable def boostZel (t : ℝ) (ht : t ≠ 0) : SL(2,ℂ) := + ⟨!![(t : ℂ), 0; 0, (t : ℂ)⁻¹], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + rw [Matrix.det_fin_two_of] + simp [mul_inv_cancel₀ htc]⟩ + +/-- The lift of the boost along the `x`-axis with rapidity `2 log t`. -/ +noncomputable def boostXel (t : ℝ) (ht : t ≠ 0) : SL(2,ℂ) := + ⟨!![((t : ℂ) + (t : ℂ)⁻¹)/2, ((t : ℂ) - (t : ℂ)⁻¹)/2; + ((t : ℂ) - (t : ℂ)⁻¹)/2, ((t : ℂ) + (t : ℂ)⁻¹)/2], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + rw [Matrix.det_fin_two_of] + field_simp + ring⟩ + +/-- The lift of the boost along the `y`-axis with rapidity `2 log t`. -/ +noncomputable def boostYel (t : ℝ) (ht : t ≠ 0) : SL(2,ℂ) := + ⟨!![((t : ℂ) + (t : ℂ)⁻¹)/2, -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹)/2; + Complex.I * ((t : ℂ) - (t : ℂ)⁻¹)/2, ((t : ℂ) + (t : ℂ)⁻¹)/2], by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + have h2 : -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2 * + (Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2) = + ((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2) := by + have hI : -Complex.I * Complex.I = 1 := by + rw [neg_mul, Complex.I_mul_I, neg_neg] + calc -Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2 * + (Complex.I * ((t : ℂ) - (t : ℂ)⁻¹) / 2) + = (-Complex.I * Complex.I) * + (((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2)) := by + ring + _ = ((t : ℂ) - (t : ℂ)⁻¹) / 2 * (((t : ℂ) - (t : ℂ)⁻¹) / 2) := by + rw [hI, one_mul] + rw [Matrix.det_fin_two_of, h2] + field_simp + ring⟩ + +/-! + +## B. Their Lorentz matrices + +-/ + +/-- The Lorentz matrix of `boostZel t`: `ch = (t² + t⁻²)/2` on the time-time + and `zz` entries, `-sh = -(t² - t⁻²)/2` on the mixed entries. -/ +noncomputable def boostMatZ (t : ℝ) : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → ℝ + | Sum.inl _, Sum.inl _ => (t^2 + (t⁻¹)^2)/2 + | Sum.inl _, Sum.inr 2 => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 2, Sum.inl _ => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 0, Sum.inr 0 => 1 + | Sum.inr 1, Sum.inr 1 => 1 + | Sum.inr 2, Sum.inr 2 => (t^2 + (t⁻¹)^2)/2 + | _, _ => 0 + +/-- The Lorentz matrix of `boostXel t`. -/ +noncomputable def boostMatX (t : ℝ) : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → ℝ + | Sum.inl _, Sum.inl _ => (t^2 + (t⁻¹)^2)/2 + | Sum.inl _, Sum.inr 0 => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 0, Sum.inl _ => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 0, Sum.inr 0 => (t^2 + (t⁻¹)^2)/2 + | Sum.inr 1, Sum.inr 1 => 1 + | Sum.inr 2, Sum.inr 2 => 1 + | _, _ => 0 + +/-- The Lorentz matrix of `boostYel t`. -/ +noncomputable def boostMatY (t : ℝ) : (Fin 1 ⊕ Fin 3) → (Fin 1 ⊕ Fin 3) → ℝ + | Sum.inl _, Sum.inl _ => (t^2 + (t⁻¹)^2)/2 + | Sum.inl _, Sum.inr 1 => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 1, Sum.inl _ => -((t^2 - (t⁻¹)^2)/2) + | Sum.inr 0, Sum.inr 0 => 1 + | Sum.inr 1, Sum.inr 1 => (t^2 + (t⁻¹)^2)/2 + | Sum.inr 2, Sum.inr 2 => 1 + | _, _ => 0 + +set_option maxHeartbeats 4000000 in +set_option linter.unusedSimpArgs false in +/-- The Lorentz matrix of the parametric `z`-boost. -/ +lemma toLorentzGroup_boostZel (t : ℝ) (ht : t ≠ 0) (a b : Fin 1 ⊕ Fin 3) : + (Lorentz.SL2C.toLorentzGroup (boostZel t ht)).1 a b = boostMatZ t a b := by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Complex.ofReal_injective ?_ + rw [Lorentz.SL2C.toLorentzGroup_eq_trace] + rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + · try simp [boostZel, boostMatZ, PauliMatrix.pauliSelfAdjoint', + PauliMatrix.pauliMatrix, Matrix.trace, Matrix.mul_apply, Fin.sum_univ_two, + Matrix.conjTranspose, Matrix.diag, Complex.conj_ofNat, + Complex.conj_ofReal, Complex.conj_I, Complex.I_sq] + try simp [Matrix.vecMul, Matrix.vecHead, Matrix.vecTail] + try push_cast + try field_simp + try ring_nf + try norm_num [Complex.I_sq, Complex.conj_ofNat] + try ring + +set_option maxHeartbeats 4000000 in +set_option linter.unusedSimpArgs false in +/-- The Lorentz matrix of the parametric `x`-boost. -/ +lemma toLorentzGroup_boostXel (t : ℝ) (ht : t ≠ 0) (a b : Fin 1 ⊕ Fin 3) : + (Lorentz.SL2C.toLorentzGroup (boostXel t ht)).1 a b = boostMatX t a b := by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Complex.ofReal_injective ?_ + rw [Lorentz.SL2C.toLorentzGroup_eq_trace] + rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + · try simp [boostXel, boostMatX, PauliMatrix.pauliSelfAdjoint', + PauliMatrix.pauliMatrix, Matrix.trace, Matrix.mul_apply, Fin.sum_univ_two, + Matrix.conjTranspose, Matrix.diag, Complex.conj_ofNat, + Complex.conj_ofReal, Complex.conj_I, Complex.I_sq] + try simp [Matrix.vecMul, Matrix.vecHead, Matrix.vecTail] + try push_cast + try field_simp + try ring_nf + try norm_num [Complex.I_sq, Complex.conj_ofNat] + try ring + +set_option maxHeartbeats 4000000 in +set_option linter.unusedSimpArgs false in +/-- The Lorentz matrix of the parametric `y`-boost. -/ +lemma toLorentzGroup_boostYel (t : ℝ) (ht : t ≠ 0) (a b : Fin 1 ⊕ Fin 3) : + (Lorentz.SL2C.toLorentzGroup (boostYel t ht)).1 a b = boostMatY t a b := by + have htc : (t : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Complex.ofReal_injective ?_ + rw [Lorentz.SL2C.toLorentzGroup_eq_trace] + rcases a with a | a <;> rcases b with b | b <;> fin_cases a <;> fin_cases b <;> + · try simp [boostYel, boostMatY, PauliMatrix.pauliSelfAdjoint', + PauliMatrix.pauliMatrix, Matrix.trace, Matrix.mul_apply, Fin.sum_univ_two, + Matrix.conjTranspose, Matrix.diag, Complex.conj_ofNat, + Complex.conj_ofReal, Complex.conj_I, Complex.I_sq] + try simp [Matrix.vecMul, Matrix.vecHead, Matrix.vecTail] + try push_cast + try field_simp + try ring_nf + try norm_num [Complex.I_sq, Complex.conj_ofNat] + try ring + + +/-! + +## C. Their inverses + +-/ + +/-- The inverse of the parametric `z`-boost is the boost at the inverse + parameter. -/ +lemma boostZel_inv (t : ℝ) (ht : t ≠ 0) : + (boostZel t ht)⁻¹ = boostZel t⁻¹ (inv_ne_zero ht) := by + ext i j + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases i <;> fin_cases j <;> + simp [boostZel, Complex.ofReal_inv, inv_inv] + +/-- The inverse of the parametric `x`-boost is the boost at the inverse + parameter. -/ +lemma boostXel_inv (t : ℝ) (ht : t ≠ 0) : + (boostXel t ht)⁻¹ = boostXel t⁻¹ (inv_ne_zero ht) := by + ext i j + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases i <;> fin_cases j <;> + · simp [boostXel, Complex.ofReal_inv, inv_inv] + try ring + +/-- The inverse of the parametric `y`-boost is the boost at the inverse + parameter. -/ +lemma boostYel_inv (t : ℝ) (ht : t ≠ 0) : + (boostYel t ht)⁻¹ = boostYel t⁻¹ (inv_ne_zero ht) := by + ext i j + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases i <;> fin_cases j <;> + · simp [boostYel, Complex.ofReal_inv, inv_inv] + try ring + + +/-- The inverse of the parametric `z`-boost, entrywise, with real entries. -/ +lemma boostZel_inv_coe (t : ℝ) (ht : t ≠ 0) : + ((boostZel t ht)⁻¹ : SL(2,ℂ)).1 = + !![(((t⁻¹ : ℝ)) : ℂ), 0; 0, ((t : ℝ) : ℂ)] := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + ext i j + fin_cases i <;> fin_cases j <;> simp [boostZel] + +/-- The inverse of the parametric `x`-boost, entrywise. -/ +lemma boostXel_inv_coe (t : ℝ) (ht : t ≠ 0) : + ((boostXel t ht)⁻¹ : SL(2,ℂ)).1 = + !![((t : ℂ) + (t : ℂ)⁻¹)/2, -(((t : ℂ) - (t : ℂ)⁻¹)/2); + -(((t : ℂ) - (t : ℂ)⁻¹)/2), ((t : ℂ) + (t : ℂ)⁻¹)/2] := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + ext i j + fin_cases i <;> fin_cases j <;> simp [boostXel] + +/-- The inverse of the parametric `y`-boost, entrywise. -/ +lemma boostYel_inv_coe (t : ℝ) (ht : t ≠ 0) : + ((boostYel t ht)⁻¹ : SL(2,ℂ)).1 = + !![((t : ℂ) + (t : ℂ)⁻¹)/2, Complex.I * ((t : ℂ) - (t : ℂ)⁻¹)/2; + -(Complex.I * ((t : ℂ) - (t : ℂ)⁻¹)/2), ((t : ℂ) + (t : ℂ)⁻¹)/2] := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + ext i j + fin_cases i <;> fin_cases j <;> · simp [boostYel]; try ring + +/-! + +## D. The uniform parametrisation and the conjugations + +The three axis boosts are conjugate: a rotation by `π/2` carries the `z`-boost to the `x`- and +`y`-boosts, so facts about the `z`-boost transport to the other axes. + +-/ + +/-- The boost along the `i`-th spatial axis. -/ +noncomputable def boostAxis : Fin 3 → (t : ℝ) → t ≠ 0 → SL(2,ℂ) + | 0, t, ht => boostXel t ht + | 1, t, ht => boostYel t ht + | 2, t, ht => boostZel t ht + +@[simp] lemma boostAxis_zero (t : ℝ) (ht : t ≠ 0) : boostAxis 0 t ht = boostXel t ht := rfl +@[simp] lemma boostAxis_one (t : ℝ) (ht : t ≠ 0) : boostAxis 1 t ht = boostYel t ht := rfl +@[simp] lemma boostAxis_two (t : ℝ) (ht : t ≠ 0) : boostAxis 2 t ht = boostZel t ht := rfl + +lemma boostAxis_inv (i : Fin 3) (t : ℝ) (ht : t ≠ 0) : + (boostAxis i t ht)⁻¹ = boostAxis i t⁻¹ (inv_ne_zero ht) := by + fin_cases i + · exact boostXel_inv t ht + · exact boostYel_inv t ht + · exact boostZel_inv t ht + +private lemma sqrtTwo_sq : (((Real.sqrt 2 : ℝ) : ℂ)) ^ 2 = 2 := by + rw [← Complex.ofReal_pow, Real.sq_sqrt (by norm_num : (0:ℝ) ≤ 2)] + norm_num + +private lemma sqrtTwo_ne_zero : (((Real.sqrt 2 : ℝ) : ℂ)) ≠ 0 := by + simp [] + +private lemma sqrtTwo_inv_mul : + ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹) * ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹) = 2⁻¹ := by + rw [← mul_inv, ← sq, sqrtTwo_sq] + +/-- The rotation by `π/2` about the `y`-axis, carrying the `z`-boost to the `x`-boost. -/ +noncomputable def rotZX : SL(2,ℂ) := + ⟨(((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, -1; 1, 1], by + rw [Matrix.det_smul, Matrix.det_fin_two_of, Fintype.card_fin, inv_pow, sqrtTwo_sq] + norm_num⟩ + +/-- The rotation by `π/2` about the `x`-axis, carrying the `z`-boost to the `y`-boost. -/ +noncomputable def rotZY : SL(2,ℂ) := + ⟨(((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, Complex.I; Complex.I, 1], by + rw [Matrix.det_smul, Matrix.det_fin_two_of, Fintype.card_fin, inv_pow, sqrtTwo_sq, + Complex.I_mul_I] + norm_num⟩ + +lemma boostXel_eq_conj (t : ℝ) (ht : t ≠ 0) : + boostXel t ht = rotZX * boostZel t ht * rotZX⁻¹ := by + have h0 := sqrtTwo_ne_zero + have hc := sqrtTwo_inv_mul + have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Subtype.ext ?_ + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + ext i j + fin_cases i <;> fin_cases j <;> + · simp [Matrix.SpecialLinearGroup.coe_mul, rotZX, boostZel, boostXel, + Matrix.mul_apply, Fin.sum_univ_two] + field_simp + simp only [sqrtTwo_sq] + try ring + +lemma boostYel_eq_conj (t : ℝ) (ht : t ≠ 0) : + boostYel t ht = rotZY * boostZel t ht * rotZY⁻¹ := by + have h0 := sqrtTwo_ne_zero + have hc := sqrtTwo_inv_mul + have htc : ((t : ℝ) : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ht + refine Subtype.ext ?_ + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + ext i j + fin_cases i <;> fin_cases j <;> + · simp [Matrix.SpecialLinearGroup.coe_mul, rotZY, boostZel, boostYel, + Matrix.mul_apply, Fin.sum_univ_two] + field_simp + simp only [sqrtTwo_sq, Complex.I_sq] + try ring + +/-- Every axis boost is a rotation of the `z`-boost. -/ +lemma exists_conj_boostAxis (i : Fin 3) : + ∃ R : SL(2,ℂ), ∀ (t : ℝ) (ht : t ≠ 0), + boostAxis i t ht = R * boostAxis 2 t ht * R⁻¹ := by + fin_cases i + · exact ⟨rotZX, fun t ht => boostXel_eq_conj t ht⟩ + · exact ⟨rotZY, fun t ht => boostYel_eq_conj t ht⟩ + · exact ⟨1, fun t ht => by simp⟩ + +end Lorentz + +end diff --git a/Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean b/Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean new file mode 100644 index 000000000..499c08d00 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Boosts/WeightGrading.lean @@ -0,0 +1,812 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.LorentzGroup.Boosts.Axis +public import Mathlib.RepresentationTheory.Basic +public import Mathlib.RingTheory.GradedAlgebra.Basic +public import Mathlib.Algebra.DirectSum.Internal +public import Mathlib.LinearAlgebra.Eigenspace.Basic +public import Mathlib.LinearAlgebra.SymmetricAlgebra.Basic +public import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic +public import Mathlib.RingTheory.TensorProduct.Basic +public import Mathlib.Algebra.Group.Pointwise.Finset.Basic +/-! +# Boost-weight gradings of representations of `SL(2,ℂ)` + +An element of a representation has boost weight `k` along the `i`-th spatial axis when the +one-parameter boost family acts on it by `t ^ k`; `boostWeightSubmodule rep i k` collects these elements. +`IsBoostGraded rep` says the representation acts on an algebra by algebra automorphisms and +that the weight spaces span along every axis. Given it, the weight spaces are independent +(they sit in eigenspaces of a single boost at distinct eigenvalues), so they decompose the +algebra as an internal direct sum, grade it as a graded algebra, and support the weight +projections `boostProj` together with their calculus: how projections interact with submodules, +weight-shifting operators, and products. + +The section-A transports (`weightSpan_tprod_eq_top`, `weightSpan_prod_eq_top`, +`weightSpan_symmetricAlgebra_eq_top`, `weightSpan_exteriorAlgebra_eq_top`, +`weightSpan_baseChange_eq_top`, `weightSpan_eq_top_of_two`) are the tools +for establishing `IsBoostGraded` for a concrete algebra, by descending to the spaces it is +built from. + +-/ + +@[expose] public section + +namespace Lorentz + +open Matrix MatrixGroups TensorProduct + +/-! + +## A. Boost weights of a general representation + +The descent to the component spaces is uniform, so it is carried out once here for an arbitrary +representation. The weight spaces are defined exactly as `boostWeightSubmodule` is, and +`weightSpan rep i = ⊤` says that they span. The point of the section is that this condition +propagates along +every construction the jet algebra is built from: tensor products, products, symmetric algebras, +exterior algebras and base change. The recursion bottoms out at a finite-dimensional space with +an eigenbasis, where the light-cone combinations do the work. + +-/ + +namespace BoostWeight + +variable {K : Type*} [Field K] [Algebra ℝ K] +variable {M N V : Type*} [AddCommGroup M] [Module K M] [AddCommGroup N] [Module K N] + [AddCommGroup V] [Module K V] +variable {i : Fin 3} + +private lemma algebraMap_ne_zero {t : ℝ} (ht : t ≠ 0) : (algebraMap ℝ K t) ≠ 0 := + fun h => ht ((algebraMap ℝ K).injective (by simpa using h)) + +/-- The weight-`w` space of a representation: the vectors scaling by `t ^ w` under the + `z`-boost at parameter `t`. -/ +def boostWeightSubmodule (rep : Representation K SL(2,ℂ) M) (i : Fin 3) (w : ℤ) : Submodule K M where + carrier := {x | ∀ (t : ℝ) (ht : t ≠ 0), + rep (Lorentz.SL2C.boostAxis i t ht) x = (algebraMap ℝ K t) ^ w • x} + add_mem' {a b} ha hb := fun t ht => by rw [map_add, ha t ht, hb t ht, smul_add] + zero_mem' := fun t ht => by rw [map_zero, smul_zero] + smul_mem' c x hx := fun t ht => by rw [map_smul, hx t ht, smul_comm] + +lemma mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {w : ℤ} {x : M} : + x ∈ boostWeightSubmodule rep i w ↔ ∀ (t : ℝ) (ht : t ≠ 0), + rep (Lorentz.SL2C.boostAxis i t ht) x = (algebraMap ℝ K t) ^ w • x := Iff.rfl + +/-- The span of all the weight spaces. -/ +def weightSpan (rep : Representation K SL(2,ℂ) M) (i : Fin 3) : Submodule K M := + ⨆ w, boostWeightSubmodule rep i w + +/-- A representation of `SL(2,ℂ)` on an algebra is **boost-graded** when it acts by algebra + automorphisms and its boost-weight spaces span, along every coordinate axis. This is the + interface behind the boost-weight grading: given it, the weight spaces decompose the algebra + as an internal direct sum, grade it as an algebra, and support the projections `boostProj` with + their calculus. -/ +class IsBoostGraded {A : Type*} [Ring A] [Algebra K A] + (rep : Representation K SL(2,ℂ) A) : Prop where + apply_one : ∀ Λ, rep Λ 1 = 1 + apply_mul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y + weightSpan_eq_top : ∀ i : Fin 3, weightSpan rep i = ⊤ + +lemma mem_weightSpan_of_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) M} {w : ℤ} {x : M} + (h : x ∈ boostWeightSubmodule rep i w) : x ∈ weightSpan rep i := + Submodule.mem_iSup_of_mem w h + +/-- A representation with a spanning family of vectors in the weight span is graded. -/ +lemma weightSpan_eq_top_of_span {rep : Representation K SL(2,ℂ) M} {S : Set M} + (hS : Submodule.span K S = ⊤) (h : ∀ x ∈ S, x ∈ weightSpan rep i) : + weightSpan rep i = ⊤ := + eq_top_iff.mpr (hS ▸ Submodule.span_le.mpr h) + +/-- A representation with a basis of vectors lying in the weight span is graded. -/ +lemma weightSpan_eq_top_of_basis {ι : Type*} {rep : Representation K SL(2,ℂ) M} + (b : Module.Basis ι K M) (h : ∀ n, b n ∈ weightSpan rep i) : weightSpan rep i = ⊤ := + weightSpan_eq_top_of_span b.span_eq (by rintro _ ⟨n, rfl⟩; exact h n) + +/-! + +### Tensor products + +-/ + +lemma tmul_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) M} {rep₂ : Representation K SL(2,ℂ) N} + {a b : ℤ} {x : M} {y : N} (hx : x ∈ boostWeightSubmodule rep i a) (hy : y ∈ boostWeightSubmodule rep₂ i b) : + x ⊗ₜ[K] y ∈ boostWeightSubmodule (rep.tprod rep₂) i (a + b) := by + intro t ht + show (TensorProduct.map _ _) _ = _ + rw [TensorProduct.map_tmul, hx t ht, hy t ht] + simp only [TensorProduct.tmul_smul, TensorProduct.smul_tmul', smul_smul] + rw [← zpow_add₀ (algebraMap_ne_zero (K := K) ht), add_comm b a] + +lemma weightSpan_tprod_eq_top {rep : Representation K SL(2,ℂ) M} + {rep₂ : Representation K SL(2,ℂ) N} (h₁ : weightSpan rep i = ⊤) + (h₂ : weightSpan rep₂ i = ⊤) : weightSpan (rep.tprod rep₂) i = ⊤ := by + refine Submodule.eq_top_iff'.mpr fun z => ?_ + induction z using TensorProduct.induction_on with + | zero => exact Submodule.zero_mem _ + | add u v hu hv => exact Submodule.add_mem _ hu hv + | tmul x y => + have hx := Submodule.eq_top_iff'.mp h₁ x + have hy := Submodule.eq_top_iff'.mp h₂ y + induction hx using Submodule.iSup_induction' with + | mem a x' hx' => + induction hy using Submodule.iSup_induction' with + | mem b y' hy' => exact mem_weightSpan_of_mem_boostWeightSubmodule (tmul_mem_boostWeightSubmodule hx' hy') + | zero => rw [TensorProduct.tmul_zero]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [TensorProduct.tmul_add]; exact Submodule.add_mem _ ihu ihv + | zero => rw [TensorProduct.zero_tmul]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [TensorProduct.add_tmul]; exact Submodule.add_mem _ ihu ihv + + +/-! + +### Products + +-/ + +lemma inl_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) M} {rep₂ : Representation K SL(2,ℂ) N} + {a : ℤ} {x : M} (hx : x ∈ boostWeightSubmodule rep i a) : + ((x, 0) : M × N) ∈ boostWeightSubmodule (rep.prod rep₂) i a := by + intro t ht + show ((rep _ x, rep₂ _ 0) : M × N) = _ + rw [map_zero, hx t ht, Prod.smul_mk, smul_zero] + +lemma inr_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) M} {rep₂ : Representation K SL(2,ℂ) N} + {a : ℤ} {y : N} (hy : y ∈ boostWeightSubmodule rep₂ i a) : + ((0, y) : M × N) ∈ boostWeightSubmodule (rep.prod rep₂) i a := by + intro t ht + show ((rep _ 0, rep₂ _ y) : M × N) = _ + rw [map_zero, hy t ht, Prod.smul_mk, smul_zero] + +lemma weightSpan_prod_eq_top {rep : Representation K SL(2,ℂ) M} + {rep₂ : Representation K SL(2,ℂ) N} (h₁ : weightSpan rep i = ⊤) + (h₂ : weightSpan rep₂ i = ⊤) : weightSpan (rep.prod rep₂) i = ⊤ := by + have hleft : ∀ x : M, ((x, (0 : N))) ∈ weightSpan (rep.prod rep₂) i := by + intro x + have hx := Submodule.eq_top_iff'.mp h₁ x + induction hx using Submodule.iSup_induction' with + | mem a u hu => exact mem_weightSpan_of_mem_boostWeightSubmodule (inl_mem_boostWeightSubmodule hu) + | zero => exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => + rw [show ((u + v, (0 : N))) = ((u, (0 : N))) + ((v, (0 : N))) from by ext <;> simp] + exact Submodule.add_mem _ ihu ihv + have hright : ∀ y : N, (((0 : M), y)) ∈ weightSpan (rep.prod rep₂) i := by + intro y + have hy := Submodule.eq_top_iff'.mp h₂ y + induction hy using Submodule.iSup_induction' with + | mem a u hu => exact mem_weightSpan_of_mem_boostWeightSubmodule (inr_mem_boostWeightSubmodule hu) + | zero => exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => + rw [show (((0 : M), u + v)) = (((0 : M), u)) + (((0 : M), v)) from by ext <;> simp] + exact Submodule.add_mem _ ihu ihv + refine Submodule.eq_top_iff'.mpr fun z => ?_ + rw [show z = ((z.1, (0 : N))) + (((0 : M), z.2)) from by ext <;> simp] + exact Submodule.add_mem _ (hleft z.1) (hright z.2) + +/-! + +### Algebras generated in degree one + +-/ + +variable {A : Type*} [Ring A] [Algebra K A] + +lemma one_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) A} (hone : ∀ Λ, rep Λ 1 = 1) : + (1 : A) ∈ boostWeightSubmodule rep i 0 := fun t _ => by rw [hone, zpow_zero, one_smul] + +lemma mul_mem_boostWeightSubmodule {rep : Representation K SL(2,ℂ) A} + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y) + {a b : ℤ} {x y : A} (hx : x ∈ boostWeightSubmodule rep i a) (hy : y ∈ boostWeightSubmodule rep i b) : + x * y ∈ boostWeightSubmodule rep i (a + b) := by + intro t ht + rw [hmul, hx t ht, hy t ht, smul_mul_smul_comm, + zpow_add₀ (algebraMap_ne_zero (K := K) ht)] + +lemma mul_mem_weightSpan {rep : Representation K SL(2,ℂ) A} + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : A), rep Λ (x * y) = rep Λ x * rep Λ y) + {x y : A} (hx : x ∈ weightSpan rep i) (hy : y ∈ weightSpan rep i) : + x * y ∈ weightSpan rep i := by + induction hx using Submodule.iSup_induction' with + | mem a u hu => + induction hy using Submodule.iSup_induction' with + | mem b v hv => exact mem_weightSpan_of_mem_boostWeightSubmodule (mul_mem_boostWeightSubmodule hmul hu hv) + | zero => rw [mul_zero]; exact Submodule.zero_mem _ + | add v w _ _ ihv ihw => rw [mul_add]; exact Submodule.add_mem _ ihv ihw + | zero => rw [zero_mul]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [add_mul]; exact Submodule.add_mem _ ihu ihv + +lemma algebraMap_mem_weightSpan {rep : Representation K SL(2,ℂ) A} + (hone : ∀ Λ, rep Λ 1 = 1) (r : K) : algebraMap K A r ∈ weightSpan rep i := by + rw [Algebra.algebraMap_eq_smul_one] + exact Submodule.smul_mem _ _ (mem_weightSpan_of_mem_boostWeightSubmodule (one_mem_boostWeightSubmodule hone)) + +/-- A symmetric algebra is boost-graded as soon as its degree-one part is. -/ +lemma weightSpan_symmetricAlgebra_eq_top {V : Type*} [AddCommGroup V] [Module K V] + {repV : Representation K SL(2,ℂ) V} + {repA : Representation K SL(2,ℂ) (SymmetricAlgebra K V)} + (hone : ∀ Λ, repA Λ 1 = 1) + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : SymmetricAlgebra K V), + repA Λ (x * y) = repA Λ x * repA Λ y) + (hι : ∀ (Λ : SL(2,ℂ)) (x : V), + repA Λ (SymmetricAlgebra.ι K V x) = SymmetricAlgebra.ι K V (repV Λ x)) + (hV : weightSpan repV i = ⊤) : weightSpan repA i = ⊤ := by + refine Submodule.eq_top_iff'.mpr fun x => ?_ + induction x using SymmetricAlgebra.induction with + | algebraMap r => exact algebraMap_mem_weightSpan hone r + | ι v => + have hv := Submodule.eq_top_iff'.mp hV v + induction hv using Submodule.iSup_induction' with + | mem a u hu => + refine mem_weightSpan_of_mem_boostWeightSubmodule (w := a) fun t ht => ?_ + rw [hι, hu t ht, map_smul] + | zero => rw [map_zero]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [map_add]; exact Submodule.add_mem _ ihu ihv + | mul u v ihu ihv => exact mul_mem_weightSpan hmul ihu ihv + | add u v ihu ihv => exact Submodule.add_mem _ ihu ihv + +/-- An exterior algebra is boost-graded as soon as its degree-one part is. -/ +lemma weightSpan_exteriorAlgebra_eq_top {V : Type*} [AddCommGroup V] [Module K V] + {repV : Representation K SL(2,ℂ) V} + {repA : Representation K SL(2,ℂ) (ExteriorAlgebra K V)} + (hone : ∀ Λ, repA Λ 1 = 1) + (hmul : ∀ (Λ : SL(2,ℂ)) (x y : ExteriorAlgebra K V), + repA Λ (x * y) = repA Λ x * repA Λ y) + (hι : ∀ (Λ : SL(2,ℂ)) (x : V), + repA Λ (ExteriorAlgebra.ι K x) = ExteriorAlgebra.ι K (repV Λ x)) + (hV : weightSpan repV i = ⊤) : weightSpan repA i = ⊤ := by + refine Submodule.eq_top_iff'.mpr fun x => ?_ + induction x using ExteriorAlgebra.induction with + | algebraMap r => exact algebraMap_mem_weightSpan hone r + | ι v => + have hv := Submodule.eq_top_iff'.mp hV v + induction hv using Submodule.iSup_induction' with + | mem a u hu => + refine mem_weightSpan_of_mem_boostWeightSubmodule (w := a) fun t ht => ?_ + rw [hι, hu t ht, map_smul] + | zero => rw [map_zero]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [map_add]; exact Submodule.add_mem _ ihu ihv + | mul u v ihu ihv => exact mul_mem_weightSpan hmul ihu ihv + | add u v ihu ihv => exact Submodule.add_mem _ ihu ihv + +/-! + +### The light-cone eigenbasis of a spacetime-indexed space + +-/ + +/-- A space with a basis indexed by spacetime directions transforming by the columns of the + Lorentz matrix is boost-graded: the light-cone combinations `b₀ ∓ b₃` are eigenvectors of + weight `±2` and the transverse directions are invariant. -/ +lemma weightSpan_eq_top_of_lorentzColumns {rep : Representation K SL(2,ℂ) M} + (b : Module.Basis (Fin 1 ⊕ Fin 3) K M) + (h : ∀ (Λ : SL(2,ℂ)) (μ : Fin 1 ⊕ Fin 3), rep Λ (b μ) = + ∑ j, algebraMap ℝ K ((Lorentz.SL2C.toLorentzGroup Λ).1 j μ) • b j) : + weightSpan rep 2 = ⊤ := by + haveI : CharZero K := charZero_of_injective_algebraMap (algebraMap ℝ K).injective + have key : ∀ (t : ℝ) (ht : t ≠ 0) (μ : Fin 1 ⊕ Fin 3), + rep (Lorentz.SL2C.boostAxis 2 t ht) (b μ) = + ∑ j, algebraMap ℝ K ((LorentzGroup.boostAxis 2 t ht).1 j μ) • b j := by + intro t ht μ + rw [h] + rfl + have hplus : b (Sum.inl 0) - b (Sum.inr 2) ∈ boostWeightSubmodule rep 2 2 := by + intro t ht + have h0 : (algebraMap ℝ K t) ≠ 0 := algebraMap_ne_zero ht + rw [map_sub, key t ht, key t ht] + simp [Fintype.sum_sum_type, Fin.sum_univ_three, LorentzGroup.boostAxis_apply] + match_scalars <;> + (field_simp; try ring_nf; try norm_num; try simp only [map_ofNat, true_or]) + have hminus : b (Sum.inl 0) + b (Sum.inr 2) ∈ boostWeightSubmodule rep 2 (-2) := by + intro t ht + have h0 : (algebraMap ℝ K t) ≠ 0 := algebraMap_ne_zero ht + rw [map_add, key t ht, key t ht] + simp [Fintype.sum_sum_type, Fin.sum_univ_three, LorentzGroup.boostAxis_apply] + match_scalars <;> (field_simp; try ring_nf; try simp only [map_ofNat]) + have htr : ∀ i' : Fin 3, i' = 0 ∨ i' = 1 → b (Sum.inr i') ∈ boostWeightSubmodule rep 2 0 := by + rintro i (rfl | rfl) <;> + · intro t ht + rw [key t ht] + simp [LorentzGroup.boostAxis_apply] + refine weightSpan_eq_top_of_basis b fun μ => ?_ + match μ with + | Sum.inl 0 => + rw [show b (Sum.inl 0) = (2⁻¹ : K) • ((b (Sum.inl 0) - b (Sum.inr 2)) + + (b (Sum.inl 0) + b (Sum.inr 2))) from by match_scalars <;> (field_simp; try ring)] + exact Submodule.smul_mem _ _ (Submodule.add_mem _ + (mem_weightSpan_of_mem_boostWeightSubmodule hplus) (mem_weightSpan_of_mem_boostWeightSubmodule hminus)) + | Sum.inr 0 => exact mem_weightSpan_of_mem_boostWeightSubmodule (htr 0 (Or.inl rfl)) + | Sum.inr 1 => exact mem_weightSpan_of_mem_boostWeightSubmodule (htr 1 (Or.inr rfl)) + | Sum.inr 2 => + rw [show b (Sum.inr 2) = (2⁻¹ : K) • ((b (Sum.inl 0) + b (Sum.inr 2)) + - (b (Sum.inl 0) - b (Sum.inr 2))) from by match_scalars <;> (field_simp; try ring)] + exact Submodule.smul_mem _ _ (Submodule.sub_mem _ + (mem_weightSpan_of_mem_boostWeightSubmodule hminus) (mem_weightSpan_of_mem_boostWeightSubmodule hplus)) + +/-! + +### Base change from the real to the complex scalars + +-/ + +lemma weightSpan_baseChange_eq_top {A : Type*} [AddCommGroup A] [Module ℝ A] + {repR : Representation ℝ SL(2,ℂ) A} {repC : Representation ℂ SL(2,ℂ) (ℂ ⊗[ℝ] A)} + (h : ∀ (Λ : SL(2,ℂ)) (c : ℂ) (y : A), repC Λ (c ⊗ₜ[ℝ] y) = c ⊗ₜ[ℝ] repR Λ y) + (hR : weightSpan repR i = ⊤) : weightSpan repC i = ⊤ := by + have htmul : ∀ (c : ℂ) (w : ℤ) (y : A), y ∈ boostWeightSubmodule repR i w → + (c ⊗ₜ[ℝ] y : ℂ ⊗[ℝ] A) ∈ boostWeightSubmodule repC i w := by + intro c w y hy t ht + rw [h, hy t ht, TensorProduct.tmul_smul, + show ((algebraMap ℝ ℝ) t) ^ w = t ^ w from by simp, + ← algebraMap_smul (R := ℝ) ℂ (t ^ w) (c ⊗ₜ[ℝ] y), map_zpow₀] + refine Submodule.eq_top_iff'.mpr fun z => ?_ + induction z using TensorProduct.induction_on with + | zero => exact Submodule.zero_mem _ + | add u v hu hv => exact Submodule.add_mem _ hu hv + | tmul c y => + have hy := Submodule.eq_top_iff'.mp hR y + induction hy using Submodule.iSup_induction' with + | mem w u hu => exact mem_weightSpan_of_mem_boostWeightSubmodule (htmul c w u hu) + | zero => rw [TensorProduct.tmul_zero]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [TensorProduct.tmul_add]; exact Submodule.add_mem _ ihu ihv + + +/-! + +### Transport between the three axes + +-/ + +/-- The axis boosts are conjugate, so the weight spaces span along every axis as soon as they + span along the `z`-axis. -/ +lemma weightSpan_eq_top_of_two {rep : Representation K SL(2,ℂ) M} (h : weightSpan rep 2 = ⊤) + (i : Fin 3) : weightSpan rep i = ⊤ := by + obtain ⟨R, hR⟩ := Lorentz.SL2C.exists_conj_boostAxis i + have hsurj : ∀ x : M, rep R (rep R⁻¹ x) = x := by + intro x + rw [← Module.End.mul_apply, ← map_mul, mul_inv_cancel, map_one, Module.End.one_apply] + have hmap : ∀ (w : ℤ) (u : M), u ∈ boostWeightSubmodule rep 2 w → rep R u ∈ boostWeightSubmodule rep i w := by + intro w u hu t ht + rw [← Module.End.mul_apply, ← map_mul, hR t ht, inv_mul_cancel_right, map_mul, + Module.End.mul_apply, hu t ht, map_smul] + refine Submodule.eq_top_iff'.mpr fun x => ?_ + obtain ⟨y, rfl⟩ : ∃ y, rep R y = x := ⟨rep R⁻¹ x, hsurj x⟩ + have hy := Submodule.eq_top_iff'.mp h y + induction hy using Submodule.iSup_induction' with + | mem w u hu => exact mem_weightSpan_of_mem_boostWeightSubmodule (hmap w u hu) + | zero => rw [map_zero]; exact Submodule.zero_mem _ + | add u v _ _ ihu ihv => rw [map_add]; exact Submodule.add_mem _ ihu ihv + +/-! + +## B. The graded-algebra theory of a boost-graded representation + +-/ + +section Theory + +omit [Algebra ℝ K] in +/-- Multiply a two-term linear decomposition into a submodule. -/ +lemma mul_mem_of_eq_smul_add_smul {p : Submodule K A} {a u v y : A} + (c d : K) (hu : a * u ∈ p) (hv : a * v ∈ p) (hy : y = c • u + d • v) : a * y ∈ p := by + subst hy + rw [mul_add, mul_smul_comm, mul_smul_comm] + exact add_mem (Submodule.smul_mem _ _ hu) (Submodule.smul_mem _ _ hv) + +omit [Algebra ℝ K] in +/-- An integer-indexed supremum of submodules supported on the weights `0`, `2`, `-2` + collapses to the three corresponding terms. -/ +lemma iSup_eq_sup_zero_two_neg_two (f : ℤ → Submodule K M) + (hf : ∀ l : ℤ, l ≠ 0 → l ≠ 2 → l ≠ -2 → f l = ⊥) : + (⨆ l, f l) = f 0 ⊔ f 2 ⊔ f (-2) := by + refine le_antisymm (iSup_le fun l => ?_) + (sup_le (sup_le (le_iSup f 0) (le_iSup f 2)) (le_iSup f (-2))) + by_cases h0 : l = 0 + · subst h0; exact le_sup_left.trans le_sup_left + by_cases h2 : l = 2 + · subst h2; exact le_sup_right.trans le_sup_left + by_cases hn2 : l = -2 + · subst hn2; exact le_sup_right + · rw [hf l h0 h2 hn2]; exact bot_le + +/-- The weight space of weight `k` sits inside the `2 ^ k` eigenspace of the boost at + parameter two. -/ +lemma boostWeightSubmodule_le_eigenspace (rep : Representation K SL(2,ℂ) M) (k : ℤ) : + boostWeightSubmodule rep i k ≤ + Module.End.eigenspace (rep (Lorentz.SL2C.boostAxis i 2 two_ne_zero)) + ((algebraMap ℝ K 2) ^ k) := by + intro x hx + rw [Module.End.mem_eigenspace_iff] + exact hx 2 two_ne_zero + +private lemma zpow_algebraMap_two_injective : + Function.Injective (fun k : ℤ => ((algebraMap ℝ K 2) ^ k)) := by + intro a b hab + simp only [← map_zpow₀] at hab + exact zpow_right_injective₀ (by norm_num) (by norm_num) ((algebraMap ℝ K).injective hab) + +/-- The weight spaces are independent: a decomposition into homogeneous parts is unique when + it exists. -/ +lemma boostWeightSubmodule_iSupIndep (rep : Representation K SL(2,ℂ) M) : + iSupIndep (boostWeightSubmodule rep i) := + ((Module.End.eigenspaces_iSupIndep + (rep (Lorentz.SL2C.boostAxis i 2 two_ne_zero) : Module.End K M)).comp + zpow_algebraMap_two_injective).mono fun k => boostWeightSubmodule_le_eigenspace rep k + +variable (rep : Representation K SL(2,ℂ) A) + +/-- The unit has boost weight zero. -/ +lemma one_mem [IsBoostGraded rep] : (1 : A) ∈ boostWeightSubmodule rep i 0 := + one_mem_boostWeightSubmodule (IsBoostGraded.apply_one (rep := rep)) + +/-- Boost weights add under multiplication. -/ +lemma mul_mem [IsBoostGraded rep] {k l : ℤ} {x y : A} (hx : x ∈ boostWeightSubmodule rep i k) + (hy : y ∈ boostWeightSubmodule rep i l) : x * y ∈ boostWeightSubmodule rep i (k + l) := + mul_mem_boostWeightSubmodule (IsBoostGraded.apply_mul (rep := rep)) hx hy + +/-- Boost weights add under multiplication, with the sum of the weights given explicitly. -/ +lemma mul_mem' [IsBoostGraded rep] {k l n : ℤ} {x y : A} (hx : x ∈ boostWeightSubmodule rep i k) + (hy : y ∈ boostWeightSubmodule rep i l) (hkl : k + l = n) : x * y ∈ boostWeightSubmodule rep i n := + hkl ▸ mul_mem rep hx hy + +instance [IsBoostGraded rep] : SetLike.GradedMonoid (boostWeightSubmodule rep i) where + one_mem := one_mem rep + mul_mem _ _ _ _ hx hy := mul_mem rep hx hy + +/-- Recover the two summands from the sum and difference: if `u + v` and `u - v` lie in a + submodule then so do `u` and `v`. -/ +lemma mem_of_add_mem_of_sub_mem {p : Submodule K M} {u v : M} + (h₁ : u + v ∈ p) (h₂ : u - v ∈ p) : u ∈ p ∧ v ∈ p := by + haveI : CharZero K := charZero_of_injective_algebraMap (algebraMap ℝ K).injective + constructor + · rw [show u = (2⁻¹ : K) • (u + v) + (2⁻¹ : K) • (u - v) from by + match_scalars <;> (field_simp; try norm_num)] + exact add_mem (Submodule.smul_mem _ _ h₁) (Submodule.smul_mem _ _ h₂) + · rw [show v = (2⁻¹ : K) • (u + v) - (2⁻¹ : K) • (u - v) from by + match_scalars <;> (field_simp; try norm_num)] + exact sub_mem (Submodule.smul_mem _ _ h₁) (Submodule.smul_mem _ _ h₂) + +/-- A product of two submodules of pure weights `k` and `l` with `k + l ≠ n` lands in the span + of the weights other than `n`. -/ +lemma mul_le_iSup_boostWeightSubmodule_of_ne [IsBoostGraded rep] {X Y : Submodule K A} {k l n : ℤ} + (hX : X ≤ boostWeightSubmodule rep i k) (hY : Y ≤ boostWeightSubmodule rep i l) (h : k + l ≠ n) : + X * Y ≤ ⨆ (j : ℤ) (_ : j ≠ n), boostWeightSubmodule rep i j := + Submodule.mul_le.2 fun _ hx _ hy => Submodule.mem_iSup_of_mem (k + l) + (Submodule.mem_iSup_of_mem h (mul_mem rep (hX hx) (hY hy))) + +/-- **Extracting the weight-`k` part of a submodule.** -/ +lemma boostWeightSubmodule_inf_eq {k : ℤ} {S V : Submodule K A} + (hS0 : S ≤ boostWeightSubmodule rep i k) (hSV : S ≤ V) + (hV : V ≤ S ⊔ ⨆ (j : ℤ) (_ : j ≠ k), boostWeightSubmodule rep i j) : + boostWeightSubmodule rep i k ⊓ V = S := by + refine le_antisymm ((inf_le_inf_left _ hV).trans ?_) (le_inf hS0 hSV) + rw [inf_comm, sup_inf_assoc_of_le _ hS0, + disjoint_iff.mp (boostWeightSubmodule_iSupIndep rep (i := i) k).symm, sup_bot_eq] + +/-- **Extracting the weight-`k` part of a span of homogeneous elements.** -/ +lemma boostWeightSubmodule_inf_eq_span {k : ℤ} {S T : Set A} {V : Submodule K A} + (hS : ∀ x ∈ S, x ∈ boostWeightSubmodule rep i k) + (hT : ∀ x ∈ T, ∃ j ≠ k, x ∈ boostWeightSubmodule rep i j) + (hSV : Submodule.span K S ≤ V) (hV : V ≤ Submodule.span K (S ∪ T)) : + boostWeightSubmodule rep i k ⊓ V = Submodule.span K S := by + refine boostWeightSubmodule_inf_eq rep (Submodule.span_le.2 hS) hSV (hV.trans ?_) + rw [Submodule.span_union] + refine sup_le le_sup_left (le_sup_of_le_right (Submodule.span_le.2 ?_)) + intro x hx + obtain ⟨j, hj, hxj⟩ := hT x hx + exact Submodule.mem_iSup_of_mem j (Submodule.mem_iSup_of_mem hj hxj) + +/-- The span of the homogeneous elements contains one. -/ +lemma one_mem_iSup_boostWeightSubmodule [IsBoostGraded rep] : (1 : A) ∈ ⨆ k, boostWeightSubmodule rep i k := + Submodule.mem_iSup_of_mem 0 (one_mem rep) + +/-- The span of the homogeneous elements is closed under multiplication. -/ +lemma mul_mem_iSup_boostWeightSubmodule [IsBoostGraded rep] {x y : A} + (hx : x ∈ ⨆ k, boostWeightSubmodule rep i k) (hy : y ∈ ⨆ k, boostWeightSubmodule rep i k) : + x * y ∈ ⨆ k, boostWeightSubmodule rep i k := by + induction hx using Submodule.iSup_induction' with + | mem k a ha => + induction hy using Submodule.iSup_induction' with + | mem l b hb => exact Submodule.mem_iSup_of_mem (k + l) (mul_mem rep ha hb) + | zero => rw [mul_zero]; exact Submodule.zero_mem _ + | add b c _ _ ihb ihc => rw [mul_add]; exact Submodule.add_mem _ ihb ihc + | zero => rw [zero_mul]; exact Submodule.zero_mem _ + | add a b _ _ iha ihb => rw [add_mul]; exact Submodule.add_mem _ iha ihb + +/-- The homogeneous elements span a subalgebra. -/ +noncomputable def subalgebra [IsBoostGraded rep] (i : Fin 3) : Subalgebra K A := + Submodule.toSubalgebra (⨆ k, boostWeightSubmodule rep i k) (one_mem_iSup_boostWeightSubmodule rep) + fun _ _ hx hy => mul_mem_iSup_boostWeightSubmodule rep hx hy + +@[simp] +lemma mem_subalgebra [IsBoostGraded rep] {i : Fin 3} {x : A} : + x ∈ subalgebra rep i ↔ x ∈ ⨆ k, boostWeightSubmodule rep i k := Iff.rfl + +/-- The decomposition into weight spaces is internal exactly when the homogeneous elements + span; independence always holds. -/ +theorem isInternal_iff : + DirectSum.IsInternal (boostWeightSubmodule rep i) ↔ (⨆ k, boostWeightSubmodule rep i k) = ⊤ := by + rw [DirectSum.isInternal_submodule_iff_iSupIndep_and_iSup_eq_top] + exact ⟨And.right, fun h => ⟨boostWeightSubmodule_iSupIndep rep, h⟩⟩ + +/-- The homogeneous elements of a boost-graded representation span, along every axis. -/ +theorem iSup_boostWeightSubmodule_eq_top [IsBoostGraded rep] : (⨆ k, boostWeightSubmodule rep i k) = ⊤ := + IsBoostGraded.weightSpan_eq_top (rep := rep) i + +/-- **The boost weight grades the algebra.** For each axis the weight spaces decompose a + boost-graded representation as an internal direct sum. -/ +theorem boostWeightSubmodule_isInternal [IsBoostGraded rep] : DirectSum.IsInternal (boostWeightSubmodule rep i) := + (isInternal_iff rep).mpr (iSup_boostWeightSubmodule_eq_top rep) + +/-- The decomposition into boost-weight components. -/ +noncomputable instance [IsBoostGraded rep] (i : Fin 3) : + DirectSum.Decomposition (boostWeightSubmodule rep i) := + (boostWeightSubmodule_isInternal rep (i := i)).chooseDecomposition + +/-- **A boost-graded representation is a graded algebra along each axis.** -/ +noncomputable instance [IsBoostGraded rep] (i : Fin 3) : GradedAlgebra (boostWeightSubmodule rep i) where + one_mem := one_mem rep + mul_mem _ _ _ _ hx hy := mul_mem rep hx hy + +/-- The projection onto the part of boost weight `k` along the `i`-th axis, read off from the + boost-weight decomposition. -/ +noncomputable def boostProj [IsBoostGraded rep] (i : Fin 3) (k : ℤ) : A →ₗ[K] A := + (boostWeightSubmodule rep i k).subtype ∘ₗ + DirectSum.component K ℤ (fun k => (boostWeightSubmodule rep i k : Submodule K A)) k ∘ₗ + (DirectSum.decomposeLinearEquiv (boostWeightSubmodule rep i)).toLinearMap + +variable [IsBoostGraded rep] + +lemma boostProj_apply (i : Fin 3) (k : ℤ) (x : A) : + boostProj rep i k x = (DirectSum.decompose (boostWeightSubmodule rep i) x k : A) := rfl + +/-- The projection lands in the weight it projects onto. -/ +lemma boostProj_mem (i : Fin 3) (k : ℤ) (x : A) : boostProj rep i k x ∈ boostWeightSubmodule rep i k := + (DirectSum.decompose (boostWeightSubmodule rep i) x k).2 + +/-- On an element of weight `k` the weight-`k` projection is the identity. -/ +@[simp] +lemma boostProj_of_mem {k : ℤ} {x : A} (hx : x ∈ boostWeightSubmodule rep i k) : boostProj rep i k x = x := + DirectSum.decompose_of_mem_same _ hx + +/-- On an element of another weight the projection vanishes. -/ +lemma boostProj_of_mem_ne {k l : ℤ} {x : A} (hx : x ∈ boostWeightSubmodule rep i l) (hlk : l ≠ k) : + boostProj rep i k x = 0 := + DirectSum.decompose_of_mem_ne _ hx hlk + +/-- An element is of weight `k` exactly when the weight-`k` projection fixes it. -/ +lemma boostProj_eq_self_iff {k : ℤ} {x : A} : boostProj rep i k x = x ↔ x ∈ boostWeightSubmodule rep i k := + ⟨fun h => h ▸ boostProj_mem rep i k x, boostProj_of_mem rep⟩ + +/-- The projections are idempotent. -/ +@[simp] +lemma boostProj_boostProj (i : Fin 3) (k : ℤ) (x : A) : + boostProj rep i k (boostProj rep i k x) = boostProj rep i k x := + boostProj_of_mem rep (boostProj_mem rep i k x) + +/-- Distinct projections are orthogonal. -/ +lemma boostProj_boostProj_of_ne {k l : ℤ} (hlk : l ≠ k) (x : A) : + boostProj rep i k (boostProj rep i l x) = 0 := + boostProj_of_mem_ne rep (boostProj_mem rep i l x) hlk + +/-- The image of the weight-`k` projection is the weight-`k` space. -/ +lemma range_boostProj (i : Fin 3) (k : ℤ) : LinearMap.range (boostProj rep i k) = boostWeightSubmodule rep i k := by + refine le_antisymm (LinearMap.range_le_iff_comap.mpr (le_top.antisymm fun x _ => ?_)) + fun x hx => ⟨x, boostProj_of_mem rep hx⟩ + exact boostProj_mem rep i k x + +/-- The weight-`k` projection fixes a submodule of pure weight `k`. -/ +lemma map_boostProj_of_le {k : ℤ} {W : Submodule K A} (h : W ≤ boostWeightSubmodule rep i k) : + W.map (boostProj rep i k) = W := by + refine le_antisymm ?_ fun x hx => ⟨x, hx, boostProj_of_mem rep (h hx)⟩ + rintro _ ⟨x, hx, rfl⟩ + rw [boostProj_of_mem rep (h hx)] + exact hx + +/-- The weight-`k` projection annihilates a submodule of pure weight `l ≠ k`. -/ +lemma map_boostProj_of_le_ne {k l : ℤ} {W : Submodule K A} (h : W ≤ boostWeightSubmodule rep i l) + (hlk : l ≠ k) : W.map (boostProj rep i k) = ⊥ := by + rw [eq_bot_iff] + rintro _ ⟨x, hx, rfl⟩ + rw [boostProj_of_mem_ne rep (h hx) hlk] + exact zero_mem ⊥ + +/-- The submodule image of a projection is unchanged by projecting again. -/ +lemma map_boostProj_idem (i : Fin 3) (k : ℤ) (X : Submodule K A) : + (X.map (boostProj rep i k)).map (boostProj rep i k) = X.map (boostProj rep i k) := + map_boostProj_of_le rep (by rintro _ ⟨y, _, rfl⟩; exact boostProj_mem rep i k y) + +/-- The weight-`k` part of a projection-closed submodule is its projection image. -/ +lemma inf_boostWeightSubmodule_eq_map {k : ℤ} {X : Submodule K A} (h : X.map (boostProj rep i k) ≤ X) : + boostWeightSubmodule rep i k ⊓ X = X.map (boostProj rep i k) := by + refine le_antisymm (fun x hx => ⟨x, hx.2, boostProj_of_mem rep hx.1⟩) (le_inf ?_ h) + rintro _ ⟨y, _, rfl⟩ + exact boostProj_mem rep i k y + +/-- An operator shifting every boost weight by `k - l` carries the weight-`l` component to + the weight-`k` component: the two sides agree on every homogeneous piece, and the pieces + span. -/ +lemma boostProj_comm {D : A →ₗ[K] A} (k l : ℤ) + (hD : ∀ {w : ℤ} {y : A}, y ∈ boostWeightSubmodule rep i w → D y ∈ boostWeightSubmodule rep i (w + k - l)) + (x : A) : boostProj rep i k (D x) = D (boostProj rep i l x) := by + have hx : x ∈ ⨆ m, boostWeightSubmodule rep i m := by rw [iSup_boostWeightSubmodule_eq_top rep]; trivial + induction hx using Submodule.iSup_induction' with + | mem w y hyw => + have hd := hD hyw + by_cases hwl : w = l + · subst hwl + rw [show w + k - w = k from by ring] at hd + rw [boostProj_of_mem rep hd, boostProj_of_mem rep hyw] + · rw [boostProj_of_mem_ne rep hyw hwl, map_zero, + boostProj_of_mem_ne rep hd (show w + k - l ≠ k from by omega)] + | zero => simp only [map_zero] + | add y₁ y₂ _ _ ih₁ ih₂ => simp only [map_add, ih₁, ih₂] + +/-- The weight-`k` part of a product of submodules is bounded by the products of the weight + parts pairing to `k`. -/ +lemma boostProj_map_mul_le (k : ℤ) (V W : Submodule K A) : + (V * W).map (boostProj rep i k) ≤ + ⨆ (l : ℤ), (V.map (boostProj rep i l)) * (W.map (boostProj rep i (k - l))) := by + classical + rw [Submodule.map_le_iff_le_comap] + refine Submodule.mul_le.2 fun v hv w hw => ?_ + rw [Submodule.mem_comap, boostProj_apply, DirectSum.decompose_mul, DirectSum.coe_mul_apply] + refine sum_mem fun ij hij => ?_ + have hk : k - ij.1 = ij.2 := by + have := (Finset.mem_filter.1 hij).2 + omega + refine Submodule.mem_iSup_of_mem ij.1 ?_ + rw [hk] + exact Submodule.mul_mem_mul ⟨v, hv, rfl⟩ ⟨w, hw, rfl⟩ + +/-- For submodules closed under the weight projections the bound of `boostProj_map_mul_le` is an + equality. -/ +lemma boostProj_map_mul (k : ℤ) {V W : Submodule K A} + (hV : ∀ l : ℤ, V.map (boostProj rep i l) ≤ V) (hW : ∀ l : ℤ, W.map (boostProj rep i l) ≤ W) : + (V * W).map (boostProj rep i k) = + ⨆ (l : ℤ), (V.map (boostProj rep i l)) * (W.map (boostProj rep i (k - l))) := by + refine le_antisymm (boostProj_map_mul_le rep k V W) (iSup_le fun l => ?_) + refine Submodule.mul_le.2 fun v' hv' w' hw' => ?_ + refine ⟨v' * w', Submodule.mul_mem_mul (hV l hv') (hW (k - l) hw'), ?_⟩ + obtain ⟨v, hv, rfl⟩ := hv' + obtain ⟨w, hw, rfl⟩ := hw' + exact boostProj_of_mem rep (mul_mem' rep (boostProj_mem rep i l v) (boostProj_mem rep i (k - l) w) + (by ring)) + +end Theory + +/-! + +## C. Weight decompositions of submodules + +-/ + +/-- A **weight decomposition** of a submodule `V`: a finitely supported family of subspaces of + pure boost weight whose supremum is `V`. Exhibiting one collapses all the per-span + boilerplate: the projection images, the weight intersections, projection-closure and the + off-support vanishing become the generic lemmas below. -/ +structure WeightDecomposition (rep : Representation K SL(2,ℂ) M) (i : Fin 3) + (V : Submodule K M) where + /-- The weight-`k` piece of the decomposition. -/ + piece : ℤ → Submodule K M + /-- The finite set of weights that occur. -/ + supp : Finset ℤ + piece_le : ∀ k, piece k ≤ boostWeightSubmodule rep i k + piece_eq_bot : ∀ k ∉ supp, piece k = ⊥ + iSup_piece : (⨆ k, piece k) = V + +namespace WeightDecomposition + +/-- Transport a weight decomposition along an equality of submodules. -/ +def copy {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {V₁ V₂ : Submodule K M} + (d₁ : WeightDecomposition rep i V₁) (hV : V₁ = V₂) : WeightDecomposition rep i V₂ where + piece := d₁.piece + supp := d₁.supp + piece_le := d₁.piece_le + piece_eq_bot := d₁.piece_eq_bot + iSup_piece := d₁.iSup_piece.trans hV + +@[simp] +lemma copy_piece {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {V₁ V₂ : Submodule K M} + (d₁ : WeightDecomposition rep i V₁) (hV : V₁ = V₂) (k : ℤ) : + (d₁.copy hV).piece k = d₁.piece k := rfl + +/-- **The join of two weight decompositions** along the same axis: the weight-`k` piece of + the join is the join of the weight-`k` pieces. -/ +def sup {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {V₁ V₂ : Submodule K M} + (d₁ : WeightDecomposition rep i V₁) (d₂ : WeightDecomposition rep i V₂) : + WeightDecomposition rep i (V₁ ⊔ V₂) where + piece k := d₁.piece k ⊔ d₂.piece k + supp := d₁.supp ∪ d₂.supp + piece_le k := sup_le (d₁.piece_le k) (d₂.piece_le k) + piece_eq_bot k hk := by + rw [d₁.piece_eq_bot k fun hk' => hk (Finset.mem_union_left _ hk'), + d₂.piece_eq_bot k fun hk' => hk (Finset.mem_union_right _ hk'), bot_sup_eq] + iSup_piece := by rw [iSup_sup_eq, d₁.iSup_piece, d₂.iSup_piece] + +@[simp] +lemma sup_piece {rep : Representation K SL(2,ℂ) M} {i : Fin 3} {V₁ V₂ : Submodule K M} + (d₁ : WeightDecomposition rep i V₁) (d₂ : WeightDecomposition rep i V₂) (k : ℤ) : + (d₁.sup d₂).piece k = d₁.piece k ⊔ d₂.piece k := rfl + +variable {rep : Representation K SL(2,ℂ) A} [IsBoostGraded rep] {i : Fin 3} + {V : Submodule K A} (d : WeightDecomposition rep i V) + +include d + +/-- Each piece sits inside the decomposed submodule. -/ +lemma piece_le_self (k : ℤ) : d.piece k ≤ V := + le_of_le_of_eq (le_iSup d.piece k) d.iSup_piece + +/-- The weight-`k` projection image of `V` is the weight-`k` piece. -/ +lemma map_boostProj (k : ℤ) : V.map (boostProj rep i k) = d.piece k := by + have h := congrArg (Submodule.map (boostProj rep i k)) d.iSup_piece + rw [← h, Submodule.map_iSup] + refine le_antisymm (iSup_le fun l => ?_) + (le_iSup_of_le k (map_boostProj_of_le rep (d.piece_le k)).ge) + by_cases hlk : l = k + · subst hlk + exact (map_boostProj_of_le rep (d.piece_le l)).le + · rw [map_boostProj_of_le_ne rep (d.piece_le l) hlk] + exact bot_le + +/-- A decomposed submodule is closed under every weight projection. -/ +lemma map_boostProj_le (k : ℤ) : V.map (boostProj rep i k) ≤ V := by + rw [d.map_boostProj] + exact d.piece_le_self k + +/-- The weight-`k` part of a decomposed submodule is the weight-`k` piece. -/ +lemma inf_eq (k : ℤ) : boostWeightSubmodule rep i k ⊓ V = d.piece k := by + rw [inf_boostWeightSubmodule_eq_map rep (d.map_boostProj_le k), d.map_boostProj] + +/-- Off the support the projection image vanishes. -/ +lemma map_boostProj_of_notMem {k : ℤ} (h : k ∉ d.supp) : + V.map (boostProj rep i k) = ⊥ := by + rw [d.map_boostProj, d.piece_eq_bot k h] + +/-- A projection-closed submodule whose projections vanish off a finite set is weight + decomposed by its projection images. -/ +noncomputable def ofMapClosed (rep : Representation K SL(2,ℂ) A) [IsBoostGraded rep] + {i : Fin 3} {V : Submodule K A} (s : Finset ℤ) + (hcl : ∀ k, V.map (boostProj rep i k) ≤ V) + (hbot : ∀ k ∉ s, V.map (boostProj rep i k) = ⊥) : + WeightDecomposition rep i V where + piece k := V.map (boostProj rep i k) + supp := s + piece_le k := by + rintro _ ⟨y, _, rfl⟩ + exact boostProj_mem rep i k y + piece_eq_bot := hbot + iSup_piece := by + classical + refine le_antisymm (iSup_le hcl) fun x hx => ?_ + rw [← DirectSum.sum_support_decompose (boostWeightSubmodule rep i) x] + exact sum_mem fun k _ => Submodule.mem_iSup_of_mem k ⟨x, hx, rfl⟩ + +open scoped Pointwise in +/-- The convolution decomposition of a product of decomposed submodules. -/ +noncomputable def mul {W : Submodule K A} (d₁ : WeightDecomposition rep i V) + (d₂ : WeightDecomposition rep i W) : WeightDecomposition rep i (V * W) := + ofMapClosed rep (d₁.supp + d₂.supp) + (fun k => by + rw [boostProj_map_mul rep k d₁.map_boostProj_le d₂.map_boostProj_le] + exact iSup_le fun l => Submodule.mul_le.2 fun a ha b hb => + Submodule.mul_mem_mul (d₁.map_boostProj_le l ha) (d₂.map_boostProj_le (k - l) hb)) + (fun k hk => by + rw [boostProj_map_mul rep k d₁.map_boostProj_le d₂.map_boostProj_le] + refine iSup_eq_bot.mpr fun l => ?_ + by_cases hl : l ∈ d₁.supp + · rw [d₂.map_boostProj, d₂.piece_eq_bot (k - l) + (fun hmem => hk (by simpa using Finset.add_mem_add hl hmem)), Submodule.mul_bot] + · rw [d₁.map_boostProj, d₁.piece_eq_bot l hl, Submodule.bot_mul]) + +end WeightDecomposition + +end BoostWeight + +end Lorentz + +end diff --git a/Physlib/Relativity/LorentzGroup/FermionicParity.lean b/Physlib/Relativity/LorentzGroup/FermionicParity.lean new file mode 100644 index 000000000..6b077e162 --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/FermionicParity.lean @@ -0,0 +1,123 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.SL2C.Basic +public import Physlib.Relativity.Fermions.Weyl.RightHanded +public import Physlib.Relativity.Tensors.ComplexTensor.Vector.Pre.Basic +/-! + +# Fermionic parity + +## i. Overview + +The homomorphism `SL(2, ℂ) → LorentzGroup 3` is two-to-one, and the nontrivial element of its +kernel is `-1`. Physically it is the rotation by `2π`: it acts as the identity on every tensor, +and as `-1` on every spinor, so it measures the parity of the number of fermionic indices +carried by a quantity. We call it the *fermionic parity*. + +Because it lies in the Lorentz group's double cover and projects to the identity, any quantity +required to be invariant under `SL(2, ℂ)` is fixed by it. A quantity carrying an odd number of +spinor indices is negated by it, and therefore vanishes: this is the selection rule that forbids +terms with an odd number of fermions. + +## ii. Key results + +- `LorentzGroup.fermionicParity` : the nontrivial element of the kernel of the covering + `SL(2, ℂ) → LorentzGroup 3`. +- `LorentzGroup.toSelfAdjointMap_fermionicParity` : it acts trivially on self-adjoint matrices. +- `LorentzGroup.toLorentzGroup_fermionicParity` : it projects to the identity Lorentz + transformation. +- `LorentzGroup.fermionicParity_sq` : it squares to one. +- `LorentzGroup.fermionicParity_ne_one` : it is not itself the identity. + +## iii. Table of contents + +- A. Fermionic parity +- B. The action on vectors and on spinors + +-/ + +@[expose] public section + +open Matrix MatrixGroups + +namespace LorentzGroup + +/-! + +## A. Fermionic parity + +-/ + +/-- Fermionic parity: the nontrivial element `-1` of the kernel of the two-to-one homomorphism + `SL(2, ℂ) → LorentzGroup 3`, that is the rotation by `2π`. It acts trivially on tensors and by + `-1` on spinors. -/ +def fermionicParity : SL(2, ℂ) := -1 + +/-- Fermionic parity acts trivially on self-adjoint matrices: conjugation by `-1` is the + identity. -/ +lemma toSelfAdjointMap_fermionicParity : + Lorentz.SL2C.toSelfAdjointMap fermionicParity = LinearMap.id := by + ext A + rw [Lorentz.SL2C.toSelfAdjointMap_apply] + simp [fermionicParity, Matrix.conjTranspose_neg] + +/-- Fermionic parity projects to the identity Lorentz transformation: it is invisible on + tensors. -/ +lemma toLorentzGroup_fermionicParity : + Lorentz.SL2C.toLorentzGroup fermionicParity = 1 := by + ext i j + show Lorentz.SL2C.toMatrix fermionicParity i j = _ + rw [Lorentz.SL2C.toMatrix, MonoidHom.coe_mk, OneHom.coe_mk, + toSelfAdjointMap_fermionicParity, LinearMap.toMatrix_id] + rfl + +@[simp] +lemma fermionicParity_sq : fermionicParity ^ 2 = 1 := by + rw [fermionicParity, neg_pow, one_pow] + simp + +/-- Fermionic parity is not the identity of `SL(2, ℂ)`: the covering is genuinely + two-to-one. -/ +lemma fermionicParity_ne_one : fermionicParity ≠ 1 := by + intro h + have h1 : ((fermionicParity : SL(2, ℂ)) : Matrix (Fin 2) (Fin 2) ℂ) 0 0 = -1 := by + simp [fermionicParity, SpecialLinearGroup.coe_neg] + rw [h] at h1 + simp only [SpecialLinearGroup.coe_one, Matrix.one_apply_eq] at h1 + norm_num at h1 + +/-! + +## B. The action on vectors and on spinors + +Fermionic parity is invisible on Lorentz vectors and acts by `-1` on Weyl spinors: this is what +makes it measure the parity of the number of spinor indices. + +-/ + +/-- Fermionic parity acts trivially on complex covariant Lorentz vectors, since it projects to + the identity Lorentz transformation. -/ +lemma coℂModule_SL2CRep_fermionicParity : + Lorentz.CoℂModule.SL2CRep fermionicParity = LinearMap.id := by + ext v + rw [Lorentz.CoℂModule.SL2CRep_val] + show ((LorentzGroup.toComplex (Lorentz.SL2C.toLorentzGroup fermionicParity))⁻¹ᵀ *ᵥ v.val) _ = _ + rw [toLorentzGroup_fermionicParity] + simp + +/-- Fermionic parity acts by `-1` on right-handed Weyl spinors. -/ +lemma rightHandedWeyl_rep_fermionicParity : + Fermion.RightHandedWeyl.rep fermionicParity = -LinearMap.id := by + refine Fermion.RightHandedWeyl.basis.ext fun i => ?_ + rw [Fermion.RightHandedWeyl.rep_apply_basis] + simp only [LinearMap.neg_apply, LinearMap.id_coe, id_eq] + rw [show ((fermionicParity : SL(2, ℂ)) : Matrix (Fin 2) (Fin 2) ℂ) = -1 from rfl] + fin_cases i <;> + simp [Matrix.one_apply, Fin.sum_univ_two] + +end LorentzGroup diff --git a/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean b/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean new file mode 100644 index 000000000..391cc6c9f --- /dev/null +++ b/Physlib/Relativity/LorentzGroup/Invariants/IsQuadLorentz.lean @@ -0,0 +1,2696 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Joseph Tooby-Smith +-/ +module + +public import Physlib.Particles.StandardModel.HiggsBoson.Basic +public import Physlib.Relativity.IsLorentzDeriv +public import Physlib.Particles.StandardModel.GaugeGroup.Jet.Basic +public import Physlib.Relativity.LorentzGroup.Boosts.WeightGrading +public import Physlib.Particles.StandardModel.GaugeGroup.SU2PermDecomposition +public import Physlib.Particles.StandardModel.GaugeGroup.GaugeWeightDecomposition +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.JetDeriv +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.LorentzAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.GaugeAction +public import Physlib.Particles.StandardModel.Matter.BosonicAlgebra.MassDim +public import Physlib.Particles.StandardModel.HiggsBoson.AlgebraValued.Basic +public import Mathlib.LinearAlgebra.TensorProduct.Pi +public import Mathlib.Analysis.Normed.Lp.Matrix +public import Mathlib.RingTheory.TensorProduct.Maps +public import Mathlib.RepresentationTheory.Invariants +public import Mathlib.Data.Matrix.Reflection +public meta import Mathlib.Data.Fintype.Sum +public meta import Mathlib.Data.Fintype.Pi +/-! +# Lorentz invariants among four four-vector indices + +`IsQuadLorentz repLorentz T` says that a family `T`, indexed by four four-vector +indices and valued in a module `B` carrying a representation of `SL(2,ℂ)`, transforms +as a tensor `T^{μ₁ μ₂ μ₃ μ₄}`. + +The main theorem `exists_smul_contraction_of_invariant` classifies the Lorentz +invariants in the span of the components: every invariant element is a linear +combination of the outer, inner and split metric contractions and the Levi-Civita +contraction. + +The section headings tell the story: the light-cone bases (B) grade the span by boost +weight, the weight-zero projection of a generator gives the recursion rounds (C), a +sieve along the three axes (D) cuts an invariant down to the tied pieces supported on +paired-or-distinct indices (E), rotation averaging reduces to `22` orbit sums (F) on +which the boost average is an explicit integer matrix (G), and a polynomial certificate +collapses the iterated rounds to the projector onto the four contractions (H, I, J). +-/ + +@[expose] public section + +namespace Lorentz + +open TensorProduct Matrix MatrixGroups Lorentz + +/-! + +## A. Quadruple Lorentz tensors and the span of their components + +-/ + +/-- A family `T` of elements of `B`, indexed by four four-vector indices, transforms as + a tensor `T^{μ₁ μ₂ μ₃ μ₄}` under the representation `repLorentz` of `SL(2,ℂ)`. -/ +structure IsQuadLorentz (B : Type*) [AddCommMonoid B] [Module ℂ B] + (repLorentz : Representation ℂ SL(2,ℂ) B) + (T : (Fin 4 → (Fin 1 ⊕ Fin 3)) → B) : Prop where + repLorentz_T : ∀ (g : SL(2,ℂ)) l, + repLorentz g (T l) = ∑ (a : Fin 4 → Fin 1 ⊕ Fin 3), + (∏ (i : Fin 4), (((SL2C.toLorentzGroup g).1 (a i) (l i) : ℝ) : ℂ)) • T a + +namespace IsQuadLorentz +set_option linter.unusedVariables false + +variable {B : Type*} [AddCommGroup B] [Module ℂ B] + {repLorentz : Representation ℂ SL(2,ℂ) B} + {T : (Fin 4 → (Fin 1 ⊕ Fin 3)) → B} + (hT : IsQuadLorentz B repLorentz T) + +/-- The span of all the components. -/ +def span (hT : IsQuadLorentz B repLorentz T) : Submodule ℂ B := ⨆ d, ℂ ∙ T d + +lemma mem_span_iff (x : B) : + x ∈ hT.span ↔ ∃ (c : (Fin 4 → (Fin 1 ⊕ Fin 3)) → ℂ), x = ∑ d, c d • T d := by + constructor + · intro hx + rw [span] at hx + refine Submodule.iSup_induction + (motive := fun y => ∃ c : (Fin 4 → (Fin 1 ⊕ Fin 3)) → ℂ, y = ∑ d, c d • T d) + (fun d => ℂ ∙ T d) hx ?_ ?_ ?_ + · intro d y hy + obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hy + refine ⟨fun e => if e = d then a else 0, ?_⟩ + simp [ite_smul, Finset.sum_ite_eq'] + · exact ⟨0, by simp⟩ + · rintro y z ⟨c₁, rfl⟩ ⟨c₂, rfl⟩ + exact ⟨c₁ + c₂, by simp [add_smul, Finset.sum_add_distrib]⟩ + · rintro ⟨c, rfl⟩ + exact sum_mem fun d _ => Submodule.smul_mem _ _ + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)) + +/-! + +## B. The light-cone basis along one axis + +## B.1. Light-cone components: their span and boost weight + +Along a spatial axis `i` the coordinate components recombine into the light-cone +components `lightCone i c`, which span the same space and are homogeneous of boost +weight `∑ j, lightConeWeight (c j)`. + +-/ + +open StandardModel.IsHiggsAlgebraValued StandardModel.IsHiggsAlgebraValued.IsDerivativeCollection + BoostWeight + +/-- The axis-`i` light-cone component of `T` at the light-cone multi-index `c`. -/ +noncomputable def lightCone (hT : IsQuadLorentz B repLorentz T) (i : Fin 3) (c : Fin 4 → Fin 4) : B := + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (d j)) • T d + +/-- Each light-cone component lies in the span of the coordinate components. -/ +lemma lightCone_mem_span (i : Fin 3) (c : Fin 4 → Fin 4) : hT.lightCone i c ∈ hT.span := + sum_mem fun d _ => Submodule.smul_mem _ _ + (Submodule.mem_iSup_of_mem d (Submodule.mem_span_singleton_self _)) + +lemma eq_sum_lightCone (i : Fin 3) (d : Fin 4 → Fin 1 ⊕ Fin 3) : + T d = ∑ c : Fin 4 → Fin 4, + (∏ j, lightConeCoeffInv i (d j) (c j)) • hT.lightCone i c := by + calc T d = ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ c : Fin 4 → Fin 4, (∏ j, lightConeCoeffInv i (d j) (c j)) * + (∏ j, lightConeCoeff i (c j) (e j))) • T e := by + simp only [sum_prod_lightConeCoeffInv, ite_smul, one_smul, zero_smul, + Finset.sum_ite_eq, Finset.mem_univ, if_true] + _ = _ := by + simp only [lightCone, Finset.smul_sum, smul_smul, Finset.sum_smul] + rw [Finset.sum_comm] + +lemma span_eq_lightCone (hT : IsQuadLorentz B repLorentz T) (i : Fin 3) : + hT.span = ⨆ c, ℂ ∙ hT.lightCone i c := by + rw [span] + refine le_antisymm (iSup_le fun d => ?_) (iSup_le fun c => ?_) + · rw [Submodule.span_singleton_le_iff_mem, hT.eq_sum_lightCone i d] + exact sum_mem fun c _ => Submodule.smul_mem _ _ + (Submodule.mem_iSup_of_mem c (Submodule.mem_span_singleton_self _)) + · rw [Submodule.span_singleton_le_iff_mem] + exact hT.lightCone_mem_span i c + + +lemma lightCone_mem_boostWeightSubmodule (i : Fin 3) (c : Fin 4 → Fin 4) : + hT.lightCone i c ∈ boostWeightSubmodule repLorentz i (∑ j, lightConeWeight (c j)) := by + refine mem_boostWeightSubmodule.2 fun t ht => ?_ + have hstep : ∀ x : Fin 4 → Fin 1 ⊕ Fin 3, + (∏ j, lightConeCoeff i (c j) (x j)) • + repLorentz (SL2C.boostAxis i t ht) (T x) + = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, + ((∏ j, lightConeCoeff i (c j) (x j)) * + (∏ j, (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) + (x j) : ℝ) : ℂ))) • T a := by + intro x + rw [hT.repLorentz_T, Finset.smul_sum] + exact Finset.sum_congr rfl fun a _ => smul_smul _ _ _ + calc repLorentz (SL2C.boostAxis i t ht) (hT.lightCone i c) + = ∑ x : Fin 4 → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (x j)) • + repLorentz (SL2C.boostAxis i t ht) (T x) := by + simp only [lightCone, map_sum, map_smul] + _ = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ x : Fin 4 → Fin 1 ⊕ Fin 3, (∏ j, lightConeCoeff i (c j) (x j)) * + (∏ j, (((SL2C.toLorentzGroup (SL2C.boostAxis i t ht)).1 (a j) + (x j) : ℝ) : ℂ))) • T a := by + simp only [hstep] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun a _ => (Finset.sum_smul).symm + _ = ∑ a : Fin 4 → Fin 1 ⊕ Fin 3, (((t : ℝ) : ℂ) ^ (∑ j, lightConeWeight (c j)) * + (∏ j, lightConeCoeff i (c j) (a j))) • T a := by + refine Finset.sum_congr rfl fun a _ => ?_ + congr 1 + exact sum_prod_lightConeCoeff i c a ht + _ = (algebraMap ℝ ℂ) t ^ (∑ j, lightConeWeight (c j)) • hT.lightCone i c := by + rw [show (algebraMap ℝ ℂ) t = ((t : ℝ) : ℂ) from rfl, lightCone, Finset.smul_sum] + exact Finset.sum_congr rfl fun a _ => (smul_smul _ _ _).symm + +/-! + +## B.2. Integer and rational mirrors of the light-cone coefficients + +Mirrors of the light-cone coefficients over `ℤ` and `ℚ`, so that the vanishing of +coefficients can be settled by `decide`. + +-/ + +/-- Integer mirror of `IsDerivativeCollection.lightConeCoeff`. -/ +def lightConeCoeffZ (i : Fin 3) (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3) : ℤ := + if κ = 0 then (if μ = Sum.inl 0 then 1 else if μ = Sum.inr i then -1 else 0) + else if κ = 1 then (if μ = Sum.inl 0 then 1 else if μ = Sum.inr i then 1 else 0) + else if κ = 2 then (if μ = Sum.inr (i + 1) then 1 else 0) + else (if μ = Sum.inr (i + 2) then 1 else 0) + +/-- The integer mirror casts to the light-cone coefficients. -/ +lemma coe_lightConeCoeffZ (i : Fin 3) (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3) : + ((lightConeCoeffZ i κ μ : ℤ) : ℂ) = lightConeCoeff i κ μ := by + rw [lightConeCoeffZ, lightConeCoeff] + split_ifs <;> norm_num + +/-- Rational mirror of `IsDerivativeCollection.lightConeCoeffInv`: entries `0`, `±2⁻¹` + and `1`, so ℚ-valued (like `lightConeTransition`) rather than integer. -/ +def lightConeCoeffInvQ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : ℚ := + if μ = Sum.inl 0 then (if κ = 0 then 2⁻¹ else if κ = 1 then 2⁻¹ else 0) + else if μ = Sum.inr i then (if κ = 0 then -2⁻¹ else if κ = 1 then 2⁻¹ else 0) + else if μ = Sum.inr (i + 1) then (if κ = 2 then 1 else 0) + else (if κ = 3 then 1 else 0) + +/-- The rational mirror casts to the inverse light-cone coefficients. -/ +lemma coe_lightConeCoeffInvQ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : + ((lightConeCoeffInvQ i μ κ : ℚ) : ℂ) = lightConeCoeffInv i μ κ := by + rw [lightConeCoeffInvQ, lightConeCoeffInv] + split_ifs <;> norm_num + +/-- Where the integer mirror vanishes, the inverse coefficient vanishes too: the zero + pattern of `lightConeCoeffInv` is the transpose of that of `lightConeCoeffZ`. -/ +lemma lightConeCoeffInv_eq_zero_of_coeffZ_eq_zero (i : Fin 3) (κ : Fin 4) + (μ : Fin 1 ⊕ Fin 3) (h : lightConeCoeffZ i κ μ = 0) : lightConeCoeffInv i μ κ = 0 := by + rcases μ with a | j + · rw [Subsingleton.elim a 0] at h ⊢ + fin_cases i <;> fin_cases κ <;> simp_all [lightConeCoeffZ, lightConeCoeffInv] + · fin_cases i <;> fin_cases j <;> fin_cases κ <;> + simp_all [lightConeCoeffZ, lightConeCoeffInv] + +/-! + +## Aside: Vanishing of homogeneous boost-weight sums + +Pure weight-grading statements with no `T` involved: the weight spaces are independent, +so a finite homogeneous sum vanishes only if every term does, and a weight-zero element +of such a sum is its weight-zero term. These belong next to +`boostWeightSubmodule_iSupIndep` in `WeightGrading`. + +-/ + +/-- Components of a vanishing homogeneous sum vanish: the boost-weight spaces are + independent. -/ +lemma eq_zero_of_sum_mem_boostWeightSubmodule + {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [AddCommGroup A] [Module K A] + {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {s : Finset ℤ} {w : ℤ → A} + (hw : ∀ m ∈ s, w m ∈ boostWeightSubmodule rep i m) + (hsum : ∑ m ∈ s, w m = 0) : + ∀ m ∈ s, w m = 0 := by + intro m₀ hm₀ + refine Submodule.disjoint_def.1 + (iSupIndep_def.1 (boostWeightSubmodule_iSupIndep rep) m₀) (w m₀) (hw m₀ hm₀) ?_ + have h : w m₀ = -∑ m ∈ s.erase m₀, w m := + eq_neg_of_add_eq_zero_left (by rw [Finset.add_sum_erase s w hm₀]; exact hsum) + rw [h] + exact neg_mem (sum_mem fun m hm => Submodule.mem_iSup_of_mem m + (Submodule.mem_iSup_of_mem (Finset.ne_of_mem_erase hm) + (hw m (Finset.mem_of_mem_erase hm)))) + +/-- A weight-zero element of a homogeneous sum is its weight-zero component: all the + other components must vanish. -/ +lemma eq_component_zero_of_mem_boostWeightSubmodule + {K : Type*} [Field K] [Algebra ℝ K] {A : Type*} [AddCommGroup A] [Module K A] + {rep : Representation K SL(2,ℂ) A} {i : Fin 3} {s : Finset ℤ} {w : ℤ → A} {x : A} + (hx : x ∈ boostWeightSubmodule rep i 0) + (hw : ∀ m ∈ s, w m ∈ boostWeightSubmodule rep i m) + (h0 : (0 : ℤ) ∈ s) (hsum : x = ∑ m ∈ s, w m) : + x = w 0 := by + have hv : ∀ m ∈ s, Function.update w 0 (w 0 - x) m ∈ boostWeightSubmodule rep i m := by + intro m hm + by_cases h : m = 0 + · subst h + rw [Function.update_self] + exact sub_mem (hw 0 h0) hx + · rw [Function.update_of_ne h] + exact hw m hm + have hsum0 : ∑ m ∈ s, Function.update w 0 (w 0 - x) m = 0 := by + rw [Finset.sum_update_of_mem h0, hsum, ← Finset.add_sum_erase s w h0, Finset.erase_eq] + abel + have h := eq_zero_of_sum_mem_boostWeightSubmodule hv hsum0 0 h0 + rw [Function.update_self] at h + exact (sub_eq_zero.1 h).symm + +/-! + +## C. The weight-zero projection of a generator + +## C.1. The boost-weight components of a generator + +Each generator `T e` is the sum of its boost-weight components `monoComponent i e m` +over the weight support along any axis. + +-/ + +/-- The axis-`i` weight-`m` component of the generator `T e`: the weight-`m` partial + sum of `eq_sum_lightCone`. -/ +noncomputable def monoComponent (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) (m : ℤ) : B := + ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = m), + (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c + +lemma monoComponent_mem_boostWeightSubmodule (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) (m : ℤ) : + hT.monoComponent i e m ∈ boostWeightSubmodule repLorentz i m := by + refine sum_mem fun c hc => Submodule.smul_mem _ _ ?_ + exact (show (∑ s, lightConeWeight (c s)) = m from (Finset.mem_filter.1 hc).2) ▸ + hT.lightCone_mem_boostWeightSubmodule i c + +/-- The possible axis-`i` boost weights of a component: the total light-cone weights + of the axis-`i` light-cone monomials appearing in `eq_sum_lightCone` with a nonzero + coefficient — those reachable through slots where the integer mirror `lightConeCoeffZ` + does not vanish. Computable, so membership can be settled by `decide`. -/ +def boostSupport (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) : Finset ℤ := + (Finset.univ.filter fun c : Fin 4 → Fin 4 => + ∀ s, lightConeCoeffZ i (c s) (e s) ≠ 0).image + fun c => ∑ s, lightConeWeight (c s) + +lemma eq_sum_monoComponent (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) : + T e = ∑ m ∈ boostSupport i e, hT.monoComponent i e m := by + have hne : ∀ c : Fin 4 → Fin 4, + ((∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c ≠ 0) → + ∀ s, lightConeCoeffZ i (c s) (e s) ≠ 0 := fun c hc s hs => + absurd (by rw [Finset.prod_eq_zero (Finset.mem_univ s) + (lightConeCoeffInv_eq_zero_of_coeffZ_eq_zero i (c s) (e s) hs), zero_smul]) hc + calc T e + = ∑ c : Fin 4 → Fin 4, + (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c := + hT.eq_sum_lightCone i e + _ = ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => + ∀ s, lightConeCoeffZ i (c s) (e s) ≠ 0), + (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c := + (Finset.sum_filter_of_ne (fun c _ => hne c)).symm + _ = ∑ m ∈ boostSupport i e, + ∑ c ∈ (Finset.univ.filter (fun c : Fin 4 → Fin 4 => + ∀ s, lightConeCoeffZ i (c s) (e s) ≠ 0)).filter + (fun c => (∑ s, lightConeWeight (c s)) = m), + (∏ s, lightConeCoeffInv i (e s) (c s)) • hT.lightCone i c := + (Finset.sum_fiberwise_of_maps_to + (fun c hc => Finset.mem_image_of_mem _ hc) _).symm + _ = ∑ m ∈ boostSupport i e, hT.monoComponent i e m := by + refine Finset.sum_congr rfl fun m hm => ?_ + rw [Finset.filter_comm, monoComponent] + exact Finset.sum_filter_of_ne fun c _ => hne c + +set_option maxRecDepth 10000 in +/-- A component is the sum of its weight components over the full weight set: as + `eq_sum_monoComponent` but over the fixed weight set common to all components. -/ +lemma eq_sum_monoComponent_univ (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) : + T e = ∑ m ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ), hT.monoComponent i e m := by + have hall : ∀ c : Fin 4 → Fin 4, + (∑ s, lightConeWeight (c s)) ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ) := by + decide + rw [hT.eq_sum_lightCone i e] + exact (Finset.sum_fiberwise_of_maps_to (fun c _ => hall c) _).symm + +/-! + +## C.2. The weight-zero transition matrix + +The matrix of the axis-`i` weight-zero projection in the `T`-basis: a sum over balanced +sector patterns of per-slot sector matrices. + +-/ + +/-- The three light-cone sectors of one index: `0` the raising direction `κ = 0`, + `1` the lowering direction `κ = 1`, `2` the transverse plane `κ ∈ {2, 3}`. -/ +def sectorIndex : Fin 4 → Fin 3 := ![0, 1, 2, 2] + +/-- The boost weight of each sector. -/ +def sectorWeight : Fin 3 → ℤ := ![2, -2, 0] + +/-- The light-cone weight of an index is the weight of its sector. -/ +lemma lightConeWeight_eq_sectorWeight (κ : Fin 4) : + lightConeWeight κ = sectorWeight (sectorIndex κ) := by decide +revert + +/-- The per-slot sector transition matrix: the single-index composite + `lightConeCoeffInvQ · lightConeCoeffZ` summed over the light-cone directions of one + sector. The three sectors resolve the identity, and `weightZeroTransition` is by + definition the balanced-sector convolution of these small matrices. -/ +def slotTransition (i : Fin 3) (κ : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : ℚ := + ∑ κ' ∈ Finset.univ.filter (fun κ' : Fin 4 => sectorIndex κ' = κ), + lightConeCoeffInvQ i μ κ' * (lightConeCoeffZ i κ' ν : ℚ) + +/-- The matrix of the axis-`i` weight-zero projection in the `T`-basis: the + coefficient of `T d` in the re-expansion of `monoComponent i e 0` through the + light-cone basis, as the sum over balanced sector patterns — as many raising as + lowering slots, `19` patterns — of the product of the per-slot sector matrices. + Rational-valued and computable; `weightZeroTransition_eq_sum_lightCone` gives the + equivalent sum over the `70` weight-zero light-cone monomials. -/ +def weightZeroTransition (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : ℚ := + ∑ w ∈ Finset.univ.filter (fun w : Fin 4 → Fin 3 => (∑ s, sectorWeight (w s)) = 0), + ∏ s, slotTransition i (w s) (e s) (d s) + +/-- Weight-zero light-cone sums are balanced-sector convolutions: a sum over the + weight-zero light-cone monomials of a product of slot factors regroups as the sum + over balanced sector patterns of the product of the slotwise sector sums. -/ +lemma sum_weightZero_eq_sum_sector {R : Type*} [CommSemiring R] (f : Fin 4 → Fin 4 → R) : + ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0), + ∏ s, f s (c s) + = ∑ w ∈ Finset.univ.filter (fun w : Fin 4 → Fin 3 => (∑ s, sectorWeight (w s)) = 0), + ∏ s, ∑ κ' ∈ Finset.univ.filter (fun κ' : Fin 4 => sectorIndex κ' = w s), f s κ' := by + have hmaps : ∀ c ∈ Finset.univ.filter + (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0), + (fun s => sectorIndex (c s)) ∈ Finset.univ.filter + (fun w : Fin 4 → Fin 3 => (∑ s, sectorWeight (w s)) = 0) := by + intro c hc + simp only [Finset.mem_filter, Finset.mem_univ, true_and] at hc ⊢ + rw [← hc] + exact (Finset.sum_congr rfl fun s _ => lightConeWeight_eq_sectorWeight (c s)).symm + rw [← Finset.sum_fiberwise_of_maps_to hmaps] + refine Finset.sum_congr rfl fun w hw => ?_ + have hw0 : (∑ s, sectorWeight (w s)) = 0 := (Finset.mem_filter.1 hw).2 + have hfiber : (Finset.univ.filter + (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0)).filter + (fun c => (fun s => sectorIndex (c s)) = w) + = Fintype.piFinset + (fun s => Finset.univ.filter (fun κ : Fin 4 => sectorIndex κ = w s)) := by + ext c + simp only [Finset.mem_filter, Finset.mem_univ, true_and, Fintype.mem_piFinset, + funext_iff] + constructor + · rintro ⟨-, hcw⟩ s + exact hcw s + · intro hcw + refine ⟨?_, hcw⟩ + rw [show (∑ s, lightConeWeight (c s)) = ∑ s, sectorWeight (w s) from + Finset.sum_congr rfl fun s _ => by rw [lightConeWeight_eq_sectorWeight, hcw s]] + exact hw0 + rw [hfiber] + exact (Finset.prod_univ_sum + (fun s => Finset.univ.filter fun κ' : Fin 4 => sectorIndex κ' = w s) + (fun s κ' => f s κ')).symm + +/-- The weight-zero transition as a light-cone sum: the sector convolution defining + `weightZeroTransition` expands to the sum over weight-zero light-cone monomials of + the composite `lightConeCoeffInvQ · lightConeCoeffZ` slot coefficients. -/ +lemma weightZeroTransition_eq_sum_lightCone (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + weightZeroTransition i d e + = ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0), + ∏ s, lightConeCoeffInvQ i (e s) (c s) * (lightConeCoeffZ i (c s) (d s) : ℚ) := by + rw [weightZeroTransition] + exact (sum_weightZero_eq_sum_sector + (fun s κ => lightConeCoeffInvQ i (e s) κ * (lightConeCoeffZ i κ (d s) : ℚ))).symm + +/-- The weight-zero component re-expanded in the `T`-basis: `monoComponent i e 0` + is the `e`-th column of `weightZeroTransition` applied to the generators. -/ +lemma monoComponent_zero_eq (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3) : + hT.monoComponent i e 0 + = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((weightZeroTransition i d e : ℚ) : ℂ) • T d := by + rw [monoComponent] + simp only [lightCone, Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← Finset.sum_smul] + congr 1 + rw [weightZeroTransition_eq_sum_lightCone] + push_cast + simp only [coe_lightConeCoeffInvQ, coe_lightConeCoeffZ, Finset.prod_mul_distrib] + +/-! + +## C.3. The boost average and iterated rounds + +An element of weight zero along all three axes re-expands through any power of the +boost-average matrix applied to its coefficients. + +-/ + +/-- The boost-average matrix `M`: the matrix of `3⁻¹(π₀⁰ + π₁⁰ + π₂⁰)` in the + `T`-basis — the average over the three axes of the weight-zero transition matrices. + Its powers drive the endgame recursion, and the certificate is a fixed rational + combination of them. -/ +def boostAverageTransition : + Matrix (Fin 4 → Fin 1 ⊕ Fin 3) (Fin 4 → Fin 1 ⊕ Fin 3) ℚ := + Matrix.of fun d e => (3⁻¹ : ℚ) * ∑ i : Fin 3, weightZeroTransition i d e + +include hT in +/-- One round of the recursion along one axis: an element of weight zero along axis + `i` expanded in the generators re-expands with the weight-zero transition matrix + applied to its coefficients — the nonzero-weight components of the expansion must + vanish, and the surviving weight-zero part is `weightZeroTransition` acting on `c`. -/ +lemma eq_sum_weightZeroTransition_smul (i : Fin 3) {x : B} + (c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) (hx : x = ∑ e, c e • T e) + (hw : x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ d, (∑ e, ((weightZeroTransition i d e : ℚ) : ℂ) * c e) • T d := by + have hsum : x = ∑ m ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ), + ∑ e, c e • hT.monoComponent i e m := by + rw [hx] + calc ∑ e, c e • T e + = ∑ e, c e • ∑ m ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ), + hT.monoComponent i e m := + Finset.sum_congr rfl fun e _ => by rw [← hT.eq_sum_monoComponent_univ i e] + _ = _ := by + simp only [Finset.smul_sum] + exact Finset.sum_comm + have hx0 : x = ∑ e, c e • hT.monoComponent i e 0 := + eq_component_zero_of_mem_boostWeightSubmodule + (w := fun m => ∑ e, c e • hT.monoComponent i e m) hw + (fun m _ => sum_mem fun e _ => Submodule.smul_mem _ _ + (hT.monoComponent_mem_boostWeightSubmodule i e m)) + (by decide) hsum + calc x = ∑ e, c e • hT.monoComponent i e 0 := hx0 + _ = ∑ e, c e • ∑ d, ((weightZeroTransition i d e : ℚ) : ℂ) • T d := + Finset.sum_congr rfl fun e _ => by rw [hT.monoComponent_zero_eq i e] + _ = ∑ d, (∑ e, ((weightZeroTransition i d e : ℚ) : ℂ) * c e) • T d := by + simp only [Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← Finset.sum_smul] + congr 1 + exact Finset.sum_congr rfl fun e _ => mul_comm _ _ + +include hT in +/-- One averaged round of the recursion: an element of weight zero along all three + axes re-expands with the boost-average matrix `M` applied to its coefficients — the + average over the axes of `eq_sum_weightZeroTransition_smul`. -/ +lemma eq_sum_boostAverageTransition_smul {x : B} + (c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) (hx : x = ∑ e, c e • T e) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ d, (∑ e, ((boostAverageTransition d e : ℚ) : ℂ) * c e) • T d := by + have hround : ∀ i : Fin 3, + x = ∑ d, (∑ e, ((weightZeroTransition i d e : ℚ) : ℂ) * c e) • T d := + fun i => hT.eq_sum_weightZeroTransition_smul i c hx (hw i) + have h3 : (3 : ℂ) • x = ∑ i : Fin 3, x := by + rw [Fin.sum_univ_three, show (3 : ℂ) = 1 + 1 + 1 from by norm_num, + add_smul, add_smul, one_smul] + calc x = (3⁻¹ : ℂ) • ((3 : ℂ) • x) := by rw [smul_smul]; norm_num + _ = (3⁻¹ : ℂ) • ∑ i : Fin 3, x := by rw [h3] + _ = (3⁻¹ : ℂ) • ∑ i : Fin 3, ∑ d, + (∑ e, ((weightZeroTransition i d e : ℚ) : ℂ) * c e) • T d := + congrArg (fun y => (3⁻¹ : ℂ) • y) (Finset.sum_congr rfl fun i _ => hround i) + _ = ∑ d, (∑ e, ((boostAverageTransition d e : ℚ) : ℂ) * c e) • T d := by + rw [Finset.sum_comm, Finset.smul_sum] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← Finset.sum_smul, smul_smul] + congr 1 + rw [Finset.sum_comm, Finset.mul_sum] + refine Finset.sum_congr rfl fun e _ => ?_ + simp only [boostAverageTransition, Matrix.of_apply] + push_cast + rw [mul_assoc, Finset.sum_mul] + +include hT in +/-- Iterated averaged rounds: an element of weight zero along all three axes + re-expands through every power of the boost-average matrix applied to its + coefficients. -/ +lemma eq_sum_pow_boostAverageTransition_smul {x : B} + (c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) (hx : x = ∑ e, c e • T e) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) (n : ℕ) : + x = ∑ d, (∑ e, (((boostAverageTransition ^ n) d e : ℚ) : ℂ) * c e) • T d := by + induction n with + | zero => + rw [hx] + refine Finset.sum_congr rfl fun d _ => ?_ + congr 1 + rw [pow_zero] + simp [Matrix.one_apply, apply_ite (fun q : ℚ => (q : ℂ)), ite_mul, Finset.sum_ite_eq] + | succ n ih => + rw [hT.eq_sum_boostAverageTransition_smul + (fun d => ∑ e, (((boostAverageTransition ^ n) d e : ℚ) : ℂ) * c e) ih hw] + refine Finset.sum_congr rfl fun d _ => ?_ + congr 1 + rw [pow_succ'] + calc ∑ e, ((boostAverageTransition d e : ℚ) : ℂ) + * ∑ f, (((boostAverageTransition ^ n) e f : ℚ) : ℂ) * c f + = ∑ e, ∑ f, ((boostAverageTransition d e : ℚ) : ℂ) + * ((((boostAverageTransition ^ n) e f : ℚ) : ℂ) * c f) := + Finset.sum_congr rfl fun e _ => by rw [Finset.mul_sum] + _ = ∑ f, (∑ e, ((boostAverageTransition d e : ℚ) : ℂ) + * (((boostAverageTransition ^ n) e f : ℚ) : ℂ)) * c f := by + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun f _ => ?_ + rw [Finset.sum_mul] + exact Finset.sum_congr rfl fun e _ => (mul_assoc _ _ _).symm + _ = ∑ e, (((boostAverageTransition * boostAverageTransition ^ n) d e : ℚ) : ℂ) + * c e := by + refine Finset.sum_congr rfl fun f _ => ?_ + congr 1 + rw [Matrix.mul_apply] + push_cast + rfl + +/-! + +## D. Sieving the span along the three boost axes + +An invariant element has boost weight zero along every axis; three successive +weight-zero extractions cut the span down to the tied pieces of the last axis. + +## D.1. Pieces along one axis + +-/ + +/-- The span of the axis-`i` light-cone components of total weight `n`. -/ +def boostPiece (i : Fin 3) (n : ℤ) : Submodule ℂ B := + ⨆ c ∈ {c : Fin 4 → Fin 4 | (∑ j, lightConeWeight (c j)) = n}, ℂ ∙ hT.lightCone i c + +lemma boostPiece_le_boostWeightSubmodule (i : Fin 3) (n : ℤ) : + hT.boostPiece i n ≤ boostWeightSubmodule repLorentz i n := by + refine iSup₂_le fun c hc => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact (show (∑ j, lightConeWeight (c j)) = n from hc) ▸ + hT.lightCone_mem_boostWeightSubmodule i c + +/-- The span regrouped by boost weight: the light-cone components sorted by their + total weight along the axis. -/ +lemma span_eq_iSup_boostPiece (i : Fin 3) : + hT.span = ⨆ n : ℤ, hT.boostPiece i n := by + rw [hT.span_eq_lightCone i] + refine le_antisymm (iSup_le fun c => ?_) (iSup_le fun n => iSup₂_le fun c _ => ?_) + · exact le_iSup_of_le (∑ s, lightConeWeight (c s)) (le_iSup₂_of_le c rfl le_rfl) + · exact le_iSup_of_le c le_rfl + +/-! + +## D.2. Pieces along a second axis + +The axis-`i` and axis-`j` light-cone bases are related slot by slot by an invertible +`4 × 4` transition matrix. An axis-`i` piece is therefore covered by axis-`j` pieces +spanned by the light-cone components reachable through nonzero transition coefficients. + +-/ + +/-- The one-slot transition matrix between two light-cone bases: the axis-`i` + light-cone direction `κ` expanded in the axis-`j` light-cone basis. Rational-valued — + the entries are `0`, `±2⁻¹` and `±1` — so that vanishing of entries is decidable; + `coe_lightConeTransition` identifies it with the composite change of basis over `ℂ`. -/ +def lightConeTransition (i j : Fin 3) (κ κ' : Fin 4) : ℚ := + if j = i then (if κ = κ' then 1 else 0) + else if j = i + 1 then + if κ = 0 then (if κ' = 0 ∨ κ' = 1 then 2⁻¹ else if κ' = 3 then -1 else 0) + else if κ = 1 then (if κ' = 0 ∨ κ' = 1 then 2⁻¹ else if κ' = 3 then 1 else 0) + else if κ = 2 then (if κ' = 0 then -2⁻¹ else if κ' = 1 then 2⁻¹ else 0) + else (if κ' = 2 then 1 else 0) + else + if κ = 0 then (if κ' = 0 ∨ κ' = 1 then 2⁻¹ else if κ' = 2 then -1 else 0) + else if κ = 1 then (if κ' = 0 ∨ κ' = 1 then 2⁻¹ else if κ' = 2 then 1 else 0) + else if κ = 2 then (if κ' = 3 then 1 else 0) + else (if κ' = 0 then -2⁻¹ else if κ' = 1 then 2⁻¹ else 0) + +/-- The transition matrix is the composite change of basis: the axis-`i` light-cone + coefficients composed with the inverse axis-`j` coefficients. -/ +lemma coe_lightConeTransition (i j : Fin 3) (κ κ' : Fin 4) : + (lightConeTransition i j κ κ' : ℂ) + = ∑ μ : Fin 1 ⊕ Fin 3, lightConeCoeff i κ μ * lightConeCoeffInv j μ κ' := by + fin_cases i <;> fin_cases j <;> fin_cases κ <;> fin_cases κ' <;> + simp [lightConeTransition, lightConeCoeff, lightConeCoeffInv, Fintype.sum_sum_type, + Fin.sum_univ_three] <;> + norm_num + +/-- Integer mirror of twice the transition matrix: the entries are `0`, `±1` and `±2`. -/ +def lightConeTransitionZ (i j : Fin 3) (κ κ' : Fin 4) : ℤ := + if j = i then (if κ = κ' then 2 else 0) + else if j = i + 1 then + if κ = 0 then (if κ' = 0 ∨ κ' = 1 then 1 else if κ' = 3 then -2 else 0) + else if κ = 1 then (if κ' = 0 ∨ κ' = 1 then 1 else if κ' = 3 then 2 else 0) + else if κ = 2 then (if κ' = 0 then -1 else if κ' = 1 then 1 else 0) + else (if κ' = 2 then 2 else 0) + else + if κ = 0 then (if κ' = 0 ∨ κ' = 1 then 1 else if κ' = 2 then -2 else 0) + else if κ = 1 then (if κ' = 0 ∨ κ' = 1 then 1 else if κ' = 2 then 2 else 0) + else if κ = 2 then (if κ' = 3 then 2 else 0) + else (if κ' = 0 then -1 else if κ' = 1 then 1 else 0) + +/-- The transition matrix is half its integer mirror. -/ +lemma coe_lightConeTransition_eq (i j : Fin 3) (κ κ' : Fin 4) : + ((lightConeTransition i j κ κ' : ℚ) : ℂ) + = 2⁻¹ * ((lightConeTransitionZ i j κ κ' : ℤ) : ℂ) := by + rw [lightConeTransition, lightConeTransitionZ] + split_ifs <;> norm_num + +/-- The transition coefficients of a multi-index factor slot by slot. -/ +lemma sum_prod_lightConeTransition (i j : Fin 3) (c c' : Fin 4 → Fin 4) : + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, (∏ s, lightConeCoeff i (c s) (d s)) * + (∏ s, lightConeCoeffInv j (d s) (c' s)) + = ∏ s, (lightConeTransition i j (c s) (c' s) : ℂ) := by + calc ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, (∏ s, lightConeCoeff i (c s) (d s)) * + (∏ s, lightConeCoeffInv j (d s) (c' s)) + = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, + ∏ s, (lightConeCoeff i (c s) (d s) * lightConeCoeffInv j (d s) (c' s)) := + Finset.sum_congr rfl fun d _ => (Finset.prod_mul_distrib).symm + _ = ∏ s, ∑ μ : Fin 1 ⊕ Fin 3, + (lightConeCoeff i (c s) μ * lightConeCoeffInv j μ (c' s)) := by + rw [Finset.prod_univ_sum, Fintype.piFinset_univ] + _ = ∏ s, (lightConeTransition i j (c s) (c' s) : ℂ) := + Finset.prod_congr rfl fun s _ => (coe_lightConeTransition i j (c s) (c' s)).symm + +/-- The change-of-axis identity: an axis-`i` light-cone component expanded in the + axis-`j` light-cone basis, with slot-wise transition coefficients. -/ +lemma lightCone_eq_sum_lightCone (i j : Fin 3) (c : Fin 4 → Fin 4) : + hT.lightCone i c = ∑ c' : Fin 4 → Fin 4, + (∏ s, (lightConeTransition i j (c s) (c' s) : ℂ)) • hT.lightCone j c' := by + calc hT.lightCone i c + = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, (∏ s, lightConeCoeff i (c s) (d s)) • T d := by + rw [lightCone] + _ = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, (∏ s, lightConeCoeff i (c s) (d s)) • + ∑ c' : Fin 4 → Fin 4, + (∏ s, lightConeCoeffInv j (d s) (c' s)) • hT.lightCone j c' := + Finset.sum_congr rfl fun d _ => by rw [← hT.eq_sum_lightCone j d] + _ = ∑ c' : Fin 4 → Fin 4, (∑ d : Fin 4 → Fin 1 ⊕ Fin 3, + (∏ s, lightConeCoeff i (c s) (d s)) * + (∏ s, lightConeCoeffInv j (d s) (c' s))) • hT.lightCone j c' := by + simp only [Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun c' _ => (Finset.sum_smul).symm + _ = _ := Finset.sum_congr rfl fun c' _ => by rw [sum_prod_lightConeTransition] + +/-- The second-level pieces: the axis-`j` light-cone components of weight `m` which + are reachable, slot by slot, from an axis-`i` multi-index of weight `n`. -/ +def boostPiece₂ (i j : Fin 3) (n m : ℤ) : Submodule ℂ B := + ⨆ c' ∈ {c' : Fin 4 → Fin 4 | (∑ s, lightConeWeight (c' s)) = m ∧ + ∃ c : Fin 4 → Fin 4, (∑ s, lightConeWeight (c s)) = n ∧ + ∀ s, lightConeTransition i j (c s) (c' s) ≠ 0}, ℂ ∙ hT.lightCone j c' + +/-- Each second-level piece is contained in the boost-weight space of its weight along + the second axis. -/ +lemma boostPiece₂_le_boostWeightSubmodule (i j : Fin 3) (n m : ℤ) : + hT.boostPiece₂ i j n m ≤ boostWeightSubmodule repLorentz j m := by + refine iSup₂_le fun c' hc' => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact (show (∑ s, lightConeWeight (c' s)) = m from hc'.1) ▸ + hT.lightCone_mem_boostWeightSubmodule j c' + +/-- The second-axis covering: each axis-`i` piece is covered by the second-level + pieces along the axis `j` — the change-of-axis coefficients vanish on unreachable + multi-indices. -/ +lemma boostPiece_le_iSup_boostPiece₂ (i j : Fin 3) (n : ℤ) : + hT.boostPiece i n ≤ ⨆ m : ℤ, hT.boostPiece₂ i j n m := by + refine iSup₂_le fun c hc => ?_ + rw [Submodule.span_singleton_le_iff_mem, hT.lightCone_eq_sum_lightCone i j c] + refine sum_mem fun c' _ => ?_ + by_cases hz : ∀ s, lightConeTransition i j (c s) (c' s) ≠ 0 + · refine Submodule.smul_mem _ _ + (Submodule.mem_iSup_of_mem (∑ s, lightConeWeight (c' s)) ?_) + rw [boostPiece₂] + exact Submodule.mem_iSup_of_mem c' (Submodule.mem_iSup_of_mem ⟨rfl, c, hc, hz⟩ + (Submodule.mem_span_singleton_self _)) + · push Not at hz + obtain ⟨s, hs⟩ := hz + rw [Finset.prod_eq_zero (Finset.mem_univ s) (by rw [hs, Rat.cast_zero]), zero_smul] + exact Submodule.zero_mem _ + +/-! + +## D.3. Tied pieces along the third axis + +Covering the doubly-weight-zero part by spans of whole light-cone components stabilises +along the third axis, so the third round instead splits each generator into its +boost-weight components along the last axis — the tied combinations — and takes the +pieces spanned by those components. + +-/ + +/-- The axis-`j` weight-`m` component of an axis-`i` light-cone component: the partial + sum of its change-of-axis expansion over the axis-`j` multi-indices of weight `m`. -/ +noncomputable def boostComponent (i j : Fin 3) (c : Fin 4 → Fin 4) (m : ℤ) : B := + ∑ c' ∈ Finset.univ.filter (fun c' : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c' s)) = m), + (∏ s, (lightConeTransition i j (c s) (c' s) : ℂ)) • hT.lightCone j c' + +/-- Each component is a boost eigenvector of its weight: it is a combination of + light-cone components of that weight. -/ +lemma boostComponent_mem_boostWeightSubmodule (i j : Fin 3) (c : Fin 4 → Fin 4) (m : ℤ) : + hT.boostComponent i j c m ∈ boostWeightSubmodule repLorentz j m := by + refine sum_mem fun c' hc' => Submodule.smul_mem _ _ ?_ + exact (Finset.mem_filter.1 hc').2 ▸ hT.lightCone_mem_boostWeightSubmodule j c' + +set_option maxRecDepth 10000 in +/-- A light-cone component is the sum of its boost-weight components along any other + axis: the change-of-axis expansion regrouped by weight. -/ +lemma lightCone_eq_sum_boostComponent (i j : Fin 3) (c : Fin 4 → Fin 4) : + hT.lightCone i c + = ∑ m ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ), hT.boostComponent i j c m := by + have hall : ∀ c' : Fin 4 → Fin 4, + (∑ s, lightConeWeight (c' s)) ∈ ({-8, -6, -4, -2, 0, 2, 4, 6, 8} : Finset ℤ) := by decide + rw [hT.lightCone_eq_sum_lightCone i j c] + exact (Finset.sum_fiberwise_of_maps_to (fun c' _ => hall c') _).symm + +/-- The tied pieces along the third axis: for each generator of the doubly-weight-zero + part, the span of its weight-`m` component along the last axis. -/ +noncomputable def boostPiece₃ (m : ℤ) : Submodule ℂ B := + ⨆ c' ∈ {c' : Fin 4 → Fin 4 | (∑ s, lightConeWeight (c' s)) = 0 ∧ + ∃ c : Fin 4 → Fin 4, (∑ s, lightConeWeight (c s)) = 0 ∧ + ∀ s, lightConeTransition 0 1 (c s) (c' s) ≠ 0}, + ℂ ∙ hT.boostComponent 1 2 c' m + +/-- Each tied piece is contained in the boost-weight space of its weight along the last + axis. -/ +lemma boostPiece₃_le_boostWeightSubmodule (m : ℤ) : + hT.boostPiece₃ m ≤ boostWeightSubmodule repLorentz 2 m := by + refine iSup₂_le fun c' _ => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact hT.boostComponent_mem_boostWeightSubmodule 1 2 c' m + +/-- The third-axis covering: the doubly-weight-zero part is covered by the tied + pieces along the last axis. -/ +lemma boostPiece₂_le_iSup_boostPiece₃ : + hT.boostPiece₂ 0 1 0 0 ≤ ⨆ m : ℤ, hT.boostPiece₃ m := by + refine iSup₂_le fun c' hc' => ?_ + rw [Submodule.span_singleton_le_iff_mem, hT.lightCone_eq_sum_boostComponent 1 2 c'] + refine sum_mem fun m _ => ?_ + refine Submodule.mem_iSup_of_mem m ?_ + rw [boostPiece₃] + exact Submodule.mem_iSup_of_mem c' (Submodule.mem_iSup_of_mem hc' + (Submodule.mem_span_singleton_self _)) + + +/-! + +## E. The support of the weight-zero tied piece + +The weight-zero tied piece only involves components `T d` whose four indices either form +two identical pairs or are all different: the remaining components cancel out of every +tied generator, by a sign involution swapping the two null light-cone directions. The +finite checks are performed by `decide` on the integer mirrors. + +## E.1. The null-swap sign involution kills the bad components + +-/ + +/-- The index vectors surviving the three boost sieves: the four indices either split + into two pairs of identical indices, or are all different. -/ +def IsPairedOrDistinct (d : Fin 4 → Fin 1 ⊕ Fin 3) : Prop := + (d 0 = d 1 ∧ d 2 = d 3) ∨ (d 0 = d 2 ∧ d 1 = d 3) ∨ (d 0 = d 3 ∧ d 1 = d 2) ∨ + Function.Injective d + +instance : DecidablePred IsPairedOrDistinct := fun d => + inferInstanceAs (Decidable ((d 0 = d 1 ∧ d 2 = d 3) ∨ (d 0 = d 2 ∧ d 1 = d 3) ∨ + (d 0 = d 3 ∧ d 1 = d 2) ∨ Function.Injective d)) + +/-- The swap of the two null light-cone directions. -/ +def swap01 : Fin 4 → Fin 4 := fun κ => if κ = 0 then 1 else if κ = 1 then 0 else κ + +/-- The sign by which the null swap changes a slot: `-1` exactly on the null-sector + mismatches. -/ +def nuZ (a : Fin 4) (μ : Fin 1 ⊕ Fin 3) : ℤ := + if μ = Sum.inl 0 then (if a = 2 then -1 else 1) + else if μ = Sum.inr 2 then (if a = 0 ∨ a = 1 then -1 else 1) + else 1 + +/-- The null swap is an involution. -/ +lemma swap01_swap01 (κ : Fin 4) : swap01 (swap01 κ) = κ := by + fin_cases κ <;> rfl + +/-- The null swap negates the light-cone weight. -/ +lemma lightConeWeight_swap01 (κ : Fin 4) : + lightConeWeight (swap01 κ) = -lightConeWeight κ := by + fin_cases κ <;> rfl + +/-- The slot identity of the sign involution: swapping the null directions of the + inner index multiplies the slot factor by the sign `nuZ`. -/ +lemma transitionZ_swap01_mul_coeffZ : + ∀ (a κ : Fin 4) (μ : Fin 1 ⊕ Fin 3), + lightConeTransitionZ 1 2 a (swap01 κ) * lightConeCoeffZ 2 (swap01 κ) μ + = nuZ a μ * (lightConeTransitionZ 1 2 a κ * lightConeCoeffZ 2 κ μ) := by + decide + +set_option maxRecDepth 40000 in +/-- The odd-count case: if the number of null-sector indices of `d` is odd, every + weight-zero inner index hits a vanishing coefficient. -/ +lemma exists_coeffZ_eq_zero_of_odd : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, + Odd (Finset.univ.filter fun s => d s = Sum.inl 0 ∨ d s = Sum.inr 2).card → + ∀ c'' : Fin 4 → Fin 4, (∑ s, lightConeWeight (c'' s)) = 0 → + ∃ s, lightConeCoeffZ 2 (c'' s) (d s) = 0 := by + decide + +set_option maxRecDepth 40000 in +/-- The parity of the sign involution: over a weight-zero generator, a component that + is neither two pairs nor all distinct, with no identically-vanishing slot and an even + null-sector count, carries total sign `-1`. -/ +lemma prod_nuZ_eq_neg_one : + ∀ c' : Fin 4 → Fin 4, (∑ s, lightConeWeight (c' s)) = 0 → + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, ¬IsPairedOrDistinct d → + ¬(∃ s, ∀ κ, lightConeTransitionZ 1 2 (c' s) κ * lightConeCoeffZ 2 κ (d s) = 0) → + ¬Odd (Finset.univ.filter fun s => d s = Sum.inl 0 ∨ d s = Sum.inr 2).card → + (∏ s, nuZ (c' s) (d s)) = -1 := by + suffices h1 : ∀ c' ∈ {c : Fin 4 → Fin 4 | (∑ s, lightConeWeight (c s)) = 0}, + ∀ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | ¬IsPairedOrDistinct d + ∧ ¬Odd (Finset.univ.filter fun s => d s = Sum.inl 0 ∨ d s = Sum.inr 2).card } , + ¬(∃ s, ∀ κ, lightConeTransitionZ 1 2 (c' s) κ * lightConeCoeffZ 2 κ (d s) = 0) → + (∏ s, nuZ (c' s) (d s)) = -1 by + intro c' hc' d hd hA hC + exact h1 c' hc' d ⟨hd, hC⟩ hA + decide + +/-- The vanishing of the bad coefficients: over a weight-zero generator, the inner + transition sum vanishes on every component that is neither two pairs nor all + distinct — slot by slot when some slot factor vanishes identically or the null-sector + count is odd, and by the sign involution otherwise. -/ +lemma sum_prod_transitionZ_coeffZ_eq_zero (c' : Fin 4 → Fin 4) + (hc' : (∑ s, lightConeWeight (c' s)) = 0) + (d : Fin 4 → Fin 1 ⊕ Fin 3) (hd : ¬IsPairedOrDistinct d) : + (∑ c'' ∈ Finset.univ.filter (fun c'' : Fin 4 → Fin 4 => + (∑ s, lightConeWeight (c'' s)) = 0), + (∏ s, lightConeTransitionZ 1 2 (c' s) (c'' s)) * + (∏ s, lightConeCoeffZ 2 (c'' s) (d s))) = 0 := by + by_cases hA : ∃ s, ∀ κ, lightConeTransitionZ 1 2 (c' s) κ * lightConeCoeffZ 2 κ (d s) = 0 + · obtain ⟨s, hs⟩ := hA + refine Finset.sum_eq_zero fun c'' _ => ?_ + rw [← Finset.prod_mul_distrib] + exact Finset.prod_eq_zero (Finset.mem_univ s) (hs (c'' s)) + by_cases hC : Odd (Finset.univ.filter fun s => d s = Sum.inl 0 ∨ d s = Sum.inr 2).card + · refine Finset.sum_eq_zero fun c'' hc'' => ?_ + obtain ⟨s, hs⟩ := exists_coeffZ_eq_zero_of_odd d hC c'' (Finset.mem_filter.1 hc'').2 + rw [← Finset.prod_mul_distrib] + refine Finset.prod_eq_zero (Finset.mem_univ s) ?_ + rw [hs, mul_zero] + have hsgn : (∏ s, nuZ (c' s) (d s)) = -1 := prod_nuZ_eq_neg_one c' hc' d hd hA hC + have hswap : ∀ c'' : Fin 4 → Fin 4, + (∏ s, lightConeTransitionZ 1 2 (c' s) (swap01 (c'' s))) * + (∏ s, lightConeCoeffZ 2 (swap01 (c'' s)) (d s)) + = (∏ s, nuZ (c' s) (d s)) * + ((∏ s, lightConeTransitionZ 1 2 (c' s) (c'' s)) * + (∏ s, lightConeCoeffZ 2 (c'' s) (d s))) := by + intro c'' + simp only [← Finset.prod_mul_distrib] + exact Finset.prod_congr rfl fun s _ => transitionZ_swap01_mul_coeffZ (c' s) (c'' s) (d s) + have hwt : ∀ c'' : Fin 4 → Fin 4, (∑ s, lightConeWeight (swap01 (c'' s))) + = -∑ s, lightConeWeight (c'' s) := fun c'' => by + rw [← Finset.sum_neg_distrib] + exact Finset.sum_congr rfl fun s _ => lightConeWeight_swap01 (c'' s) + have hrei : (∑ c'' ∈ Finset.univ.filter (fun c'' : Fin 4 → Fin 4 => + (∑ s, lightConeWeight (c'' s)) = 0), + (∏ s, lightConeTransitionZ 1 2 (c' s) (c'' s)) * + (∏ s, lightConeCoeffZ 2 (c'' s) (d s))) + = ∑ c'' ∈ Finset.univ.filter (fun c'' : Fin 4 → Fin 4 => + (∑ s, lightConeWeight (c'' s)) = 0), + ((∏ s, lightConeTransitionZ 1 2 (c' s) (swap01 (c'' s))) * + (∏ s, lightConeCoeffZ 2 (swap01 (c'' s)) (d s))) := by + refine Finset.sum_nbij' (i := fun c'' => fun s => swap01 (c'' s)) + (j := fun c'' => fun s => swap01 (c'' s)) ?_ ?_ ?_ ?_ ?_ + · intro c'' hc'' + refine Finset.mem_filter.2 ⟨Finset.mem_univ _, ?_⟩ + rw [hwt, (Finset.mem_filter.1 hc'').2, neg_zero] + · intro c'' hc'' + refine Finset.mem_filter.2 ⟨Finset.mem_univ _, ?_⟩ + rw [hwt, (Finset.mem_filter.1 hc'').2, neg_zero] + · intro c'' _ + funext s + rw [swap01_swap01] + · intro c'' _ + funext s + rw [swap01_swap01] + · intro c'' _ + simp only [swap01_swap01] + have hkey := hrei.trans ((Finset.sum_congr rfl fun c'' _ => hswap c'').trans + (Finset.mul_sum _ _ _).symm) + rw [hsgn] at hkey + omega + +/-! + +## E.2. Sector compatibility and the support of the weight-zero transition + +The weight-zero transition out of a paired-or-distinct index vanishes on every bad +index: a sector-incompatible slot kills every summand, and otherwise the null-swap +involution carries sign `-1`. + +-/ + +/-- Two direction letters lie in compatible sectors for the axis-`i` transition: both + in the null sector, or equal. -/ +def SameSlotSector (i : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : Prop := + ((μ = Sum.inl 0 ∨ μ = Sum.inr i) ∧ (ν = Sum.inl 0 ∨ ν = Sum.inr i)) ∨ μ = ν + +instance (i : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : Decidable (SameSlotSector i μ ν) := + inferInstanceAs (Decidable (_ ∨ _)) + +/-- A sector-incompatible slot annihilates every slot factor. -/ +lemma slot_eq_zero_of_not_sameSlotSector : + ∀ (i : Fin 3) (μ ν : Fin 1 ⊕ Fin 3), ¬SameSlotSector i μ ν → + ∀ κ, lightConeCoeffInvQ i μ κ * (lightConeCoeffZ i κ ν : ℚ) = 0 := by + decide +kernel + +/-- The sign by which the null swap changes an axis-`i` slot factor. -/ +def nuSignZ (i : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : ℤ := + (if μ = Sum.inr i then -1 else 1) * (if ν = Sum.inr i then -1 else 1) + +/-- Swapping the null directions multiplies the slot factor by the sign. -/ +lemma invQ_swap01_mul_coeffZ_swap01 : + ∀ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) (ν : Fin 1 ⊕ Fin 3), + lightConeCoeffInvQ i μ (swap01 κ) * (lightConeCoeffZ i (swap01 κ) ν : ℚ) + = (nuSignZ i μ ν : ℚ) + * (lightConeCoeffInvQ i μ κ * (lightConeCoeffZ i κ ν : ℚ)) := by + decide +kernel + +set_option maxRecDepth 100000 in +/-- The sign of a sector-compatible parity mismatch: a paired-or-distinct column + index against a bad row index with all slots sector-compatible carries sign `-1`. -/ +lemma prod_nuSignZ_eq_neg_one : + ∀ (i : Fin 3) (e : Fin 4 → Fin 1 ⊕ Fin 3), IsPairedOrDistinct e → + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, ¬IsPairedOrDistinct d → + (∀ s, SameSlotSector i (e s) (d s)) → + (∏ s, nuSignZ i (e s) (d s)) = -1 := by + suffices h1 : ∀ i : Fin 3, ∀ e ∈ {e : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct e}, + ∀ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | ¬IsPairedOrDistinct d}, + (∀ s, SameSlotSector i (e s) (d s)) → (∏ s, nuSignZ i (e s) (d s)) = -1 by + intro i e he d hd hs + exact h1 i e he d hd hs + decide +kernel + +/-- Support of the weight-zero transition: the transition out of a + paired-or-distinct index vanishes on every bad index. -/ +lemma weightZeroTransition_eq_zero_of_not_isPairedOrDistinct (i : Fin 3) + {d e : Fin 4 → Fin 1 ⊕ Fin 3} (he : IsPairedOrDistinct e) + (hd : ¬IsPairedOrDistinct d) : weightZeroTransition i d e = 0 := by + by_cases hA : ∀ s, SameSlotSector i (e s) (d s) + · have hsgn := prod_nuSignZ_eq_neg_one i e he d hd hA + have hswap : ∀ c : Fin 4 → Fin 4, + (∏ s, lightConeCoeffInvQ i (e s) (swap01 (c s)) * + (lightConeCoeffZ i (swap01 (c s)) (d s) : ℚ)) + = ((∏ s, nuSignZ i (e s) (d s) : ℤ) : ℚ) * + ∏ s, lightConeCoeffInvQ i (e s) (c s) * (lightConeCoeffZ i (c s) (d s) : ℚ) := by + intro c + push_cast + rw [← Finset.prod_mul_distrib] + exact Finset.prod_congr rfl fun s _ => invQ_swap01_mul_coeffZ_swap01 i (e s) (c s) (d s) + have hwt : ∀ c : Fin 4 → Fin 4, (∑ s, lightConeWeight (swap01 (c s))) + = -∑ s, lightConeWeight (c s) := fun c => by + rw [← Finset.sum_neg_distrib] + exact Finset.sum_congr rfl fun s _ => lightConeWeight_swap01 (c s) + have hrei : weightZeroTransition i d e + = ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => + (∑ s, lightConeWeight (c s)) = 0), + ∏ s, lightConeCoeffInvQ i (e s) (swap01 (c s)) * + (lightConeCoeffZ i (swap01 (c s)) (d s) : ℚ) := by + rw [weightZeroTransition_eq_sum_lightCone] + refine Finset.sum_nbij' (i := fun c => fun s => swap01 (c s)) + (j := fun c => fun s => swap01 (c s)) ?_ ?_ ?_ ?_ ?_ + · intro c hc + exact Finset.mem_filter.2 ⟨Finset.mem_univ _, by + rw [hwt, (Finset.mem_filter.1 hc).2, neg_zero]⟩ + · intro c hc + exact Finset.mem_filter.2 ⟨Finset.mem_univ _, by + rw [hwt, (Finset.mem_filter.1 hc).2, neg_zero]⟩ + · intro c _ + funext s + rw [swap01_swap01] + · intro c _ + funext s + rw [swap01_swap01] + · intro c _ + simp only [swap01_swap01] + have hkey := hrei.trans ((Finset.sum_congr rfl fun c _ => hswap c).trans + (Finset.mul_sum _ _ _).symm) + rw [← weightZeroTransition_eq_sum_lightCone, hsgn] at hkey + push_cast at hkey + linarith [hkey] + · push Not at hA + obtain ⟨s₀, hs₀⟩ := hA + rw [weightZeroTransition_eq_sum_lightCone] + refine Finset.sum_eq_zero fun c _ => ?_ + exact Finset.prod_eq_zero (Finset.mem_univ s₀) + (slot_eq_zero_of_not_sameSlotSector i (e s₀) (d s₀) hs₀ (c s₀)) + +/-- Support of the boost average: the average out of a paired-or-distinct index is + supported on the paired-or-distinct indices. -/ +lemma boostAverageTransition_eq_zero_of_not_isPairedOrDistinct + {d e : Fin 4 → Fin 1 ⊕ Fin 3} (he : IsPairedOrDistinct e) + (hd : ¬IsPairedOrDistinct d) : boostAverageTransition d e = 0 := by + simp only [boostAverageTransition, Matrix.of_apply] + rw [Finset.sum_eq_zero fun i _ => + weightZeroTransition_eq_zero_of_not_isPairedOrDistinct i he hd, mul_zero] + +/-! + +## E.3. The support of the tied piece + +-/ + +/-- The expansion of the weight-zero tied component into monomials: the coefficient + of each component `T d` is a sixteenth of the integer transition sum. -/ +lemma boostComponent_zero_eq (c' : Fin 4 → Fin 4) : + hT.boostComponent 1 2 c' 0 = ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, + ((16⁻¹ : ℂ) * ((∑ c'' ∈ Finset.univ.filter (fun c'' : Fin 4 → Fin 4 => + (∑ s, lightConeWeight (c'' s)) = 0), + (∏ s, lightConeTransitionZ 1 2 (c' s) (c'' s)) * + (∏ s, lightConeCoeffZ 2 (c'' s) (d s)) : ℤ) : ℂ)) • T d := by + rw [boostComponent] + simp only [lightCone, Finset.smul_sum, smul_smul] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun d _ => ?_ + rw [← Finset.sum_smul] + congr 1 + push_cast + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun c'' _ => ?_ + simp only [coe_lightConeTransition_eq, ← coe_lightConeCoeffZ, Finset.prod_mul_distrib, + Finset.prod_const, Finset.card_univ, Fintype.card_fin] + ring + +/-- The weight-zero tied component of every weight-zero generator is supported on the + paired-or-distinct components. -/ +lemma boostComponent_zero_mem_iSup_pairedOrDistinct (c' : Fin 4 → Fin 4) + (hc' : (∑ s, lightConeWeight (c' s)) = 0) : + hT.boostComponent 1 2 c' 0 ∈ + ⨆ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d}, ℂ ∙ T d := by + rw [hT.boostComponent_zero_eq c'] + refine sum_mem fun d _ => ?_ + by_cases hd : IsPairedOrDistinct d + · exact Submodule.smul_mem _ _ (Submodule.mem_iSup_of_mem d + (Submodule.mem_iSup_of_mem hd (Submodule.mem_span_singleton_self _))) + · rw [sum_prod_transitionZ_coeffZ_eq_zero c' hc' d hd, Int.cast_zero, mul_zero, zero_smul] + exact Submodule.zero_mem _ + +/-- The support of the weight-zero tied piece: it is spanned by the components whose + four indices either form two identical pairs or are all different. The one-pair and + three-of-a-kind components cancel out of every tied generator. -/ +lemma boostPiece₃_zero_le_iSup_pairedOrDistinct : + hT.boostPiece₃ 0 ≤ + ⨆ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d}, ℂ ∙ T d := by + refine iSup₂_le fun c' hc' => ?_ + rw [Submodule.span_singleton_le_iff_mem] + exact hT.boostComponent_zero_mem_iSup_pairedOrDistinct c' hc'.1 + +/-- The span of the paired-or-distinct components. -/ +def pairedOrDistinctSubmodule : Submodule ℂ B := + ⨆ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d}, ℂ ∙ T d + + +/-! + +## F. Averaging over the cyclic rotation of the axes + +The cyclic rotation `x → y → z → x` of the spatial axes acts on components by cycling +every index; averaging over it carries the paired-or-distinct span onto the span of +`22` orbit sums, on which the boost average acts by an explicit matrix. + +## F.1. Rotation equivariance of the transition matrices + +Rotating all direction letters advances the axis of the light-cone coefficients, so +the boost average is invariant under rotating both of its indices. + +-/ + +/-- Rotating the direction letter advances the axis of the light-cone coefficient. -/ +lemma lightConeCoeffZ_cycDir : + ∀ (i : Fin 3) (κ : Fin 4) (μ : Fin 1 ⊕ Fin 3), + lightConeCoeffZ (i + 1) κ (cycDir μ) = lightConeCoeffZ i κ μ := by + decide + +/-- Integer mirror of `lightConeCoeffInvQ`: twice the inverse coefficients, so that + slot identities can be settled by kernel `decide` over `ℤ`. -/ +def lightConeCoeffInvZ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : ℤ := + if μ = Sum.inl 0 then (if κ = 0 then 1 else if κ = 1 then 1 else 0) + else if μ = Sum.inr i then (if κ = 0 then -1 else if κ = 1 then 1 else 0) + else if μ = Sum.inr (i + 1) then (if κ = 2 then 2 else 0) + else (if κ = 3 then 2 else 0) + +/-- The integer mirror casts to twice the inverse coefficients. -/ +lemma coe_lightConeCoeffInvZ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : + ((lightConeCoeffInvZ i μ κ : ℤ) : ℚ) = 2 * lightConeCoeffInvQ i μ κ := by + rw [lightConeCoeffInvZ, lightConeCoeffInvQ] + split_ifs <;> norm_num + +/-- Rotating the direction letter advances the axis of the integer mirror. -/ +lemma lightConeCoeffInvZ_cycDir : + ∀ (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4), + lightConeCoeffInvZ (i + 1) (cycDir μ) κ = lightConeCoeffInvZ i μ κ := by + decide + +/-- Rotating the direction letter advances the axis of the inverse coefficient. -/ +lemma lightConeCoeffInvQ_cycDir (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) (κ : Fin 4) : + lightConeCoeffInvQ (i + 1) (cycDir μ) κ = lightConeCoeffInvQ i μ κ := by + have h := congrArg (fun n : ℤ => (n : ℚ)) (lightConeCoeffInvZ_cycDir i μ κ) + simp only [coe_lightConeCoeffInvZ] at h + linarith + +/-- Rotation equivariance of the weight-zero transition: rotating both indices + advances the axis. -/ +lemma weightZeroTransition_cycDir (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + weightZeroTransition (i + 1) (fun s => cycDir (d s)) (fun s => cycDir (e s)) + = weightZeroTransition i d e := by + rw [weightZeroTransition_eq_sum_lightCone, weightZeroTransition_eq_sum_lightCone] + refine Finset.sum_congr rfl fun c _ => Finset.prod_congr rfl fun s _ => ?_ + rw [lightConeCoeffInvQ_cycDir, lightConeCoeffZ_cycDir] + +/-- Rotation invariance of the boost average: the average over the axes is + invariant under rotating both indices. -/ +lemma boostAverageTransition_cycDir (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + boostAverageTransition (fun s => cycDir (d s)) (fun s => cycDir (e s)) + = boostAverageTransition d e := by + simp only [boostAverageTransition, Matrix.of_apply] + congr 1 + exact (Fintype.sum_equiv (Equiv.addRight (1 : Fin 3)) _ _ fun i => + (weightZeroTransition_cycDir i d e).symm).symm + +/-- The cyclic rotation of directions has order three. -/ +lemma cycDir_cycDir_cycDir : ∀ μ : Fin 1 ⊕ Fin 3, cycDir (cycDir (cycDir μ)) = μ := by + decide + +/-- Rotating the column index moves a double rotation to the row index. -/ +lemma boostAverageTransition_cycDir_right (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + boostAverageTransition d (fun s => cycDir (e s)) + = boostAverageTransition (fun s => cycDir (cycDir (d s))) e := by + conv_lhs => rw [show d = (fun s => cycDir (cycDir (cycDir (d s)))) from + funext fun s => (cycDir_cycDir_cycDir (d s)).symm] + exact boostAverageTransition_cycDir (fun s => cycDir (cycDir (d s))) e + +/-- Rotating the column index twice moves a single rotation to the row index. -/ +lemma boostAverageTransition_cycDir_right2 (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + boostAverageTransition d (fun s => cycDir (cycDir (e s))) + = boostAverageTransition (fun s => cycDir (d s)) e := by + calc boostAverageTransition d (fun s => cycDir (cycDir (e s))) + = boostAverageTransition (fun s => cycDir (cycDir (d s))) (fun s => cycDir (e s)) := + boostAverageTransition_cycDir_right d (fun s => cycDir (e s)) + _ = boostAverageTransition (fun s => cycDir (d s)) e := + boostAverageTransition_cycDir (fun s => cycDir (d s)) e + +/-! + +## F.2. The rotational average and orbit sums + +-/ + +/-- The rotation orbit of an index vector: the indices that `d` is carried onto by + the powers of the cyclic rotation `x → y → z → x` of the rotational average. -/ +def rotationIndexSet (d : Fin 4 → Fin 1 ⊕ Fin 3) : Finset (Fin 4 → Fin 1 ⊕ Fin 3) := + {d, fun s => cycDir (d s), fun s => cycDir (cycDir (d s))} + +/-- The rotational average: the mean of the action of the three powers of the cyclic + rotation `x → y → z → x`. -/ +noncomputable def rotationAverage : B →ₗ[ℂ] B := + (3⁻¹ : ℂ) • ((LinearMap.id : B →ₗ[ℂ] B) + repLorentz rotationCycle + + repLorentz (rotationCycle ^ 2)) + +/-- The action of the rotational average on the paired-or-distinct span: the image of + the weight-zero tied piece's support under averaging over the cyclic rotation. -/ +noncomputable def rotationSubmodule : Submodule ℂ B := + (pairedOrDistinctSubmodule (T := T)).map (rotationAverage (repLorentz := repLorentz)) + +include hT in +/-- The cyclic rotation acts on components by cycling every index. -/ +lemma repLorentz_rotationCycle_apply (d : Fin 4 → Fin 1 ⊕ Fin 3) : + repLorentz rotationCycle (T d) = T (fun s => cycDir (d s)) := by + have hcoef : ∀ a : Fin 4 → Fin 1 ⊕ Fin 3, + (∏ s, (((SL2C.toLorentzGroup rotationCycle).1 (a s) (d s) : ℝ) : ℂ)) + = if a = fun s => cycDir (d s) then 1 else 0 := by + intro a + by_cases had : a = fun s => cycDir (d s) + · rw [if_pos had] + refine Finset.prod_eq_one fun s _ => ?_ + rw [toLorentzGroup_rotationCycle_apply, if_pos (congrFun had s), Complex.ofReal_one] + · rw [if_neg had] + obtain ⟨s, hs⟩ := Function.ne_iff.1 had + refine Finset.prod_eq_zero (Finset.mem_univ s) ?_ + rw [toLorentzGroup_rotationCycle_apply, if_neg hs, Complex.ofReal_zero] + rw [hT.repLorentz_T] + simp only [hcoef, ite_smul, one_smul, zero_smul, Finset.sum_ite_eq', Finset.mem_univ, + if_true] + +/-- The sum of a component over its rotation orbit — the un-normalised rotational + average of `T d`. Its support is `rotationIndexSet d`. -/ +noncomputable def rotationOrbitSum (d : Fin 4 → Fin 1 ⊕ Fin 3) : B := + T d + T (fun s => cycDir (d s)) + T (fun s => cycDir (cycDir (d s))) + +include hT in +/-- The rotational average carries a component to a third of its orbit sum. -/ +lemma rotationAverage_apply (d : Fin 4 → Fin 1 ⊕ Fin 3) : + rotationAverage (repLorentz := repLorentz) (T d) + = (3⁻¹ : ℂ) • rotationOrbitSum (T := T) d := by + rw [rotationAverage, sq, map_mul, rotationOrbitSum] + simp only [LinearMap.smul_apply, LinearMap.add_apply, LinearMap.id_apply, + Module.End.mul_apply, hT.repLorentz_rotationCycle_apply] + +include hT in +/-- The rotational average of the paired-or-distinct span, presented by orbit + sums. -/ +lemma rotationSubmodule_eq : + rotationSubmodule (repLorentz := repLorentz) (T := T) + = ⨆ d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d}, + ℂ ∙ rotationOrbitSum (T := T) d := by + rw [rotationSubmodule, pairedOrDistinctSubmodule] + simp only [Submodule.map_iSup] + refine iSup_congr fun d => iSup_congr fun hd => ?_ + rw [Submodule.map_span, Set.image_singleton, hT.rotationAverage_apply d] + exact Submodule.span_singleton_smul_eq ((by norm_num : (3⁻¹ : ℂ) ≠ 0).isUnit) _ + +include hT in +/-- Extraction from the rotational average: an element of the averaged span is a + combination of the orbit sums of the paired-or-distinct components. -/ +lemma exists_eq_sum_of_mem_rotationSubmodule {x : B} + (hx : x ∈ rotationSubmodule (repLorentz := repLorentz) (T := T)) : + ∃ c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ, + x = ∑ d ∈ Finset.univ.filter (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => IsPairedOrDistinct d), + c d • rotationOrbitSum (T := T) d := by + rw [hT.rotationSubmodule_eq] at hx + refine Submodule.iSup_induction + (motive := fun y => ∃ c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ, + y = ∑ d ∈ Finset.univ.filter (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => IsPairedOrDistinct d), + c d • rotationOrbitSum (T := T) d) + (fun d => ⨆ _ : d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d}, + ℂ ∙ rotationOrbitSum (T := T) d) hx ?_ ?_ ?_ + · intro d y hy + by_cases hd : IsPairedOrDistinct d + · rw [iSup_pos (show d ∈ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d} + from hd)] at hy + obtain ⟨a, rfl⟩ := Submodule.mem_span_singleton.1 hy + refine ⟨fun e => if e = d then a else 0, ?_⟩ + simp [ite_smul, Finset.sum_ite_eq', hd] + · rw [iSup_neg (show d ∉ {d : Fin 4 → Fin 1 ⊕ Fin 3 | IsPairedOrDistinct d} + from hd)] at hy + rw [Submodule.mem_bot] at hy + exact ⟨0, by simp [hy]⟩ + · exact ⟨0, by simp⟩ + · rintro y z ⟨c₁, rfl⟩ ⟨c₂, rfl⟩ + exact ⟨c₁ + c₂, by simp [add_smul, Finset.sum_add_distrib]⟩ + +/-! + +## F.3. The 22 canonical orbit representatives + +`rotationOrbitSum` is constant on rotation orbits, so the extraction over all +paired-or-distinct indices collapses to one term per orbit; `rotationSubset` lists the +canonical representatives explicitly. + +-/ + +omit [Module ℂ B] in +/-- The orbit sum is invariant under rotating the index. -/ +lemma rotationOrbitSum_cycDir (d : Fin 4 → Fin 1 ⊕ Fin 3) : + rotationOrbitSum (T := T) (fun s => cycDir (d s)) = rotationOrbitSum (T := T) d := by + simp only [rotationOrbitSum] + rw [show (fun s => cycDir (cycDir (cycDir (d s)))) = d from + funext fun s => cycDir_cycDir_cycDir (d s)] + abel + +/-- An index is the canonical representative of its rotation orbit when its first + spatial letter, if any, is the first spatial direction. -/ +def IsOrbitRep (d : Fin 4 → Fin 1 ⊕ Fin 3) : Prop := + (∀ s, d s = Sum.inl 0) ∨ ∃ s, d s = Sum.inr 0 ∧ ∀ s' < s, d s' = Sum.inl 0 + +instance : DecidablePred IsOrbitRep := fun d => + inferInstanceAs (Decidable + ((∀ s, d s = Sum.inl 0) ∨ ∃ s, d s = Sum.inr 0 ∧ ∀ s' < s, d s' = Sum.inl 0)) + +/-- The canonical representative of the rotation orbit of an index. -/ +def orbitRepOf (d : Fin 4 → Fin 1 ⊕ Fin 3) : Fin 4 → Fin 1 ⊕ Fin 3 := + if IsOrbitRep d then d + else if IsOrbitRep (fun s => cycDir (d s)) then fun s => cycDir (d s) + else fun s => cycDir (cycDir (d s)) + +omit [Module ℂ B] in +/-- The orbit sum of an index equals that of its canonical representative. -/ +lemma rotationOrbitSum_orbitRepOf (d : Fin 4 → Fin 1 ⊕ Fin 3) : + rotationOrbitSum (T := T) (orbitRepOf d) = rotationOrbitSum (T := T) d := by + rw [orbitRepOf] + split_ifs + · rfl + · exact rotationOrbitSum_cycDir (T := T) d + · exact (rotationOrbitSum_cycDir (T := T) _).trans (rotationOrbitSum_cycDir (T := T) d) + +/-- The `22` canonical orbit representatives of the paired-or-distinct indices under + cyclic rotation. -/ +def rotationSubset : Finset (Fin 4 → Fin 1 ⊕ Fin 3) := + {![Sum.inl 0, Sum.inl 0, Sum.inl 0, Sum.inl 0], + ![Sum.inl 0, Sum.inl 0, Sum.inr 0, Sum.inr 0], + ![Sum.inl 0, Sum.inr 0, Sum.inl 0, Sum.inr 0], + ![Sum.inl 0, Sum.inr 0, Sum.inr 0, Sum.inl 0], + ![Sum.inl 0, Sum.inr 0, Sum.inr 1, Sum.inr 2], + ![Sum.inl 0, Sum.inr 0, Sum.inr 2, Sum.inr 1], + ![Sum.inr 0, Sum.inl 0, Sum.inl 0, Sum.inr 0], + ![Sum.inr 0, Sum.inl 0, Sum.inr 0, Sum.inl 0], + ![Sum.inr 0, Sum.inl 0, Sum.inr 1, Sum.inr 2], + ![Sum.inr 0, Sum.inl 0, Sum.inr 2, Sum.inr 1], + ![Sum.inr 0, Sum.inr 0, Sum.inl 0, Sum.inl 0], + ![Sum.inr 0, Sum.inr 0, Sum.inr 0, Sum.inr 0], + ![Sum.inr 0, Sum.inr 0, Sum.inr 1, Sum.inr 1], + ![Sum.inr 0, Sum.inr 0, Sum.inr 2, Sum.inr 2], + ![Sum.inr 0, Sum.inr 1, Sum.inl 0, Sum.inr 2], + ![Sum.inr 0, Sum.inr 1, Sum.inr 0, Sum.inr 1], + ![Sum.inr 0, Sum.inr 1, Sum.inr 1, Sum.inr 0], + ![Sum.inr 0, Sum.inr 1, Sum.inr 2, Sum.inl 0], + ![Sum.inr 0, Sum.inr 2, Sum.inl 0, Sum.inr 1], + ![Sum.inr 0, Sum.inr 2, Sum.inr 0, Sum.inr 2], + ![Sum.inr 0, Sum.inr 2, Sum.inr 1, Sum.inl 0], + ![Sum.inr 0, Sum.inr 2, Sum.inr 2, Sum.inr 0]} + +set_option maxRecDepth 10000 in +/-- The canonical representative of a paired-or-distinct index is one of the `22` + listed representatives. -/ +lemma orbitRepOf_mem_rotationSubset : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, IsPairedOrDistinct d → + orbitRepOf d ∈ rotationSubset := by + decide + +include hT in +/-- Extraction over unique orbit representatives: an element of the rotational + average is a combination of the orbit sums of the `22` canonical representatives — + one term per orbit. -/ +lemma exists_eq_sum_rotationSubset_of_mem_rotationSubmodule {x : B} + (hx : x ∈ rotationSubmodule (repLorentz := repLorentz) (T := T)) : + ∃ c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ, + x = ∑ d ∈ rotationSubset, c d • rotationOrbitSum (T := T) d := by + obtain ⟨c, rfl⟩ := hT.exists_eq_sum_of_mem_rotationSubmodule hx + refine ⟨fun r => ∑ d ∈ (Finset.univ.filter + (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => IsPairedOrDistinct d)).filter + (fun d => orbitRepOf d = r), c d, ?_⟩ + calc ∑ d ∈ Finset.univ.filter (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => IsPairedOrDistinct d), + c d • rotationOrbitSum (T := T) d + = ∑ r ∈ rotationSubset, ∑ d ∈ (Finset.univ.filter + (fun d : Fin 4 → Fin 1 ⊕ Fin 3 => IsPairedOrDistinct d)).filter + (fun d => orbitRepOf d = r), + c d • rotationOrbitSum (T := T) d := + (Finset.sum_fiberwise_of_maps_to (fun d hd => + orbitRepOf_mem_rotationSubset d (Finset.mem_filter.1 hd).2) _).symm + _ = _ := by + refine Finset.sum_congr rfl fun r hr => ?_ + rw [Finset.sum_smul] + refine Finset.sum_congr rfl fun d hd => ?_ + rw [show rotationOrbitSum (T := T) r = rotationOrbitSum (T := T) d from + (Finset.mem_filter.1 hd).2 ▸ rotationOrbitSum_orbitRepOf (T := T) d] + +/-! + +## F.4. The averaged round on the orbit-sum span + +Through the orbit multiplicities `rotationOrbitCoeff`, an averaged round re-expands a +combination of representative orbit sums through the row-orbit sums of the boost +average. + +-/ + +/-- The listed representatives are paired-or-distinct. -/ +lemma isPairedOrDistinct_of_mem_rotationSubset : + ∀ d ∈ rotationSubset, IsPairedOrDistinct d := by + decide +kernel + +/-- Goodness is preserved by rotating the index. -/ +lemma isPairedOrDistinct_cycDir : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, IsPairedOrDistinct d → + IsPairedOrDistinct (fun s => cycDir (d s)) := by + decide +kernel + +/-- The multiplicity with which `d` appears among the three rotations of `e`. -/ +def rotationOrbitCoeff (e d : Fin 4 → Fin 1 ⊕ Fin 3) : ℤ := + (if d = e then 1 else 0) + (if d = (fun s => cycDir (e s)) then 1 else 0) + + (if d = (fun s => cycDir (cycDir (e s))) then 1 else 0) + +/-- Only members of the orbit of a listed representative meet its indicator. -/ +lemma orbitRepOf_eq_of_rotationOrbitCoeff_ne_zero : + ∀ r ∈ rotationSubset, ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, + rotationOrbitCoeff r d ≠ 0 → orbitRepOf d = r := by + decide +kernel + +/-- The orbit of the canonical representative is the orbit. -/ +lemma rotationIndexSet_orbitRepOf : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, + rotationIndexSet (orbitRepOf d) = rotationIndexSet d := by + decide +kernel + +/-- The multiplicity of an index in its own orbit: `3` on a rotation-fixed index and + `1` otherwise. -/ +lemma rotationOrbitCoeff_orbitRepOf : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, rotationOrbitCoeff (orbitRepOf d) d + = if (fun s => cycDir (d s)) = d then 3 else 1 := by + decide +kernel + +/-- An index not fixed by the rotation has three distinct rotations. -/ +lemma cycDir_orbit_distinct : + ∀ d : Fin 4 → Fin 1 ⊕ Fin 3, (fun s => cycDir (d s)) ≠ d → + ((fun s => cycDir (cycDir (d s))) ≠ d + ∧ (fun s => cycDir (cycDir (d s))) ≠ (fun s => cycDir (d s))) := by + decide +kernel + +/-- The orbit indicator of a good index vanishes on every bad index. -/ +lemma rotationOrbitCoeff_eq_zero {r d : Fin 4 → Fin 1 ⊕ Fin 3} + (hr : IsPairedOrDistinct r) (hd : ¬IsPairedOrDistinct d) : + rotationOrbitCoeff r d = 0 := by + have h1 : ¬(d = r) := fun h => hd (by rw [h]; exact hr) + have h2 : ¬(d = fun s => cycDir (r s)) := fun h => + hd (by rw [h]; exact isPairedOrDistinct_cycDir r hr) + have h3 : ¬(d = fun s => cycDir (cycDir (r s))) := fun h => + hd (by rw [h]; exact isPairedOrDistinct_cycDir _ (isPairedOrDistinct_cycDir r hr)) + rw [rotationOrbitCoeff, if_neg h1, if_neg h2, if_neg h3] + norm_num + +/-- Sums over the orbit of the representative: for any weighting, the sum over the + orbit of the canonical representative times the multiplicity equals the plain sum + over the three rotations. -/ +lemma sum_rotationIndexSet_orbitRepOf_mul (f : (Fin 4 → Fin 1 ⊕ Fin 3) → ℚ) + (d : Fin 4 → Fin 1 ⊕ Fin 3) : + (∑ d' ∈ rotationIndexSet (orbitRepOf d), f d') + * ((rotationOrbitCoeff (orbitRepOf d) d : ℤ) : ℚ) + = f d + f (fun s => cycDir (d s)) + f (fun s => cycDir (cycDir (d s))) := by + rw [rotationIndexSet_orbitRepOf d, rotationOrbitCoeff_orbitRepOf d] + by_cases hfix : (fun s => cycDir (d s)) = d + · have h2 : (fun s => cycDir (cycDir (d s))) = d := by + funext s + rw [congrFun hfix s, congrFun hfix s] + rw [rotationIndexSet, if_pos hfix, hfix, h2, + show ({d, d, d} : Finset (Fin 4 → Fin 1 ⊕ Fin 3)) = {d} from by simp, + Finset.sum_singleton] + push_cast + ring + · obtain ⟨h31, h32⟩ := cycDir_orbit_distinct d hfix + rw [rotationIndexSet, if_neg hfix, + Finset.sum_insert (by + simp only [Finset.mem_insert, Finset.mem_singleton] + push Not + exact ⟨fun h => hfix h.symm, fun h => h31 h.symm⟩), + Finset.sum_insert (by + simp only [Finset.mem_singleton] + exact fun h => h32 h.symm), + Finset.sum_singleton] + push_cast + ring + +/-- The rotated columns collapse onto the representatives: for a good column index, + the sum of the boost average over the three rotated columns equals the + representative-indexed combination of its row-orbit sums. -/ +lemma boostAverageTransition_orbit_eq (e : Fin 4 → Fin 1 ⊕ Fin 3) + (he : IsPairedOrDistinct e) (d : Fin 4 → Fin 1 ⊕ Fin 3) : + boostAverageTransition d e + boostAverageTransition d (fun s => cycDir (e s)) + + boostAverageTransition d (fun s => cycDir (cycDir (e s))) + = ∑ r ∈ rotationSubset, + (∑ d' ∈ rotationIndexSet r, boostAverageTransition d' e) + * ((rotationOrbitCoeff r d : ℤ) : ℚ) := by + by_cases hd : IsPairedOrDistinct d + · have hsingle : (∑ r ∈ rotationSubset, + (∑ d' ∈ rotationIndexSet r, boostAverageTransition d' e) + * ((rotationOrbitCoeff r d : ℤ) : ℚ)) + = (∑ d' ∈ rotationIndexSet (orbitRepOf d), boostAverageTransition d' e) + * ((rotationOrbitCoeff (orbitRepOf d) d : ℤ) : ℚ) := + Finset.sum_eq_single_of_mem _ (orbitRepOf_mem_rotationSubset d hd) + (fun r hr hne => by + rcases eq_or_ne (rotationOrbitCoeff r d) 0 with h0 | h0 + · rw [h0] + push_cast + ring + · exact absurd (orbitRepOf_eq_of_rotationOrbitCoeff_ne_zero r hr d h0).symm hne) + rw [hsingle, + sum_rotationIndexSet_orbitRepOf_mul (fun d' => boostAverageTransition d' e) d, + boostAverageTransition_cycDir_right, boostAverageTransition_cycDir_right2] + ring + · have hs1 := isPairedOrDistinct_cycDir e he + have hs2 := isPairedOrDistinct_cycDir _ hs1 + have hz : (∑ r ∈ rotationSubset, + (∑ d' ∈ rotationIndexSet r, boostAverageTransition d' e) + * ((rotationOrbitCoeff r d : ℤ) : ℚ)) = 0 := + Finset.sum_eq_zero fun r hr => by + rw [rotationOrbitCoeff_eq_zero + (isPairedOrDistinct_of_mem_rotationSubset r hr) hd] + push_cast + ring + rw [hz, boostAverageTransition_eq_zero_of_not_isPairedOrDistinct he hd, + boostAverageTransition_eq_zero_of_not_isPairedOrDistinct hs1 hd, + boostAverageTransition_eq_zero_of_not_isPairedOrDistinct hs2 hd] + norm_num + +/-- Orbit-sum expansions in components: a combination of orbit sums over the + representatives, expanded into the generators through the orbit indicator. -/ +lemma sum_rotationSubset_smul_rotationOrbitSum (b : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) : + ∑ d ∈ rotationSubset, b d • rotationOrbitSum (T := T) d + = ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ d ∈ rotationSubset, b d * ((rotationOrbitCoeff d e : ℤ) : ℂ)) • T e := by + calc ∑ d ∈ rotationSubset, b d • rotationOrbitSum (T := T) d + = ∑ d ∈ rotationSubset, ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + (b d * ((rotationOrbitCoeff d e : ℤ) : ℂ)) • T e := by + refine Finset.sum_congr rfl fun d _ => ?_ + rw [rotationOrbitSum] + simp [rotationOrbitCoeff, apply_ite (fun n : ℤ => (n : ℂ)), mul_add, add_smul, + mul_ite, ite_smul, Finset.sum_add_distrib, Finset.sum_ite_eq', smul_add] + _ = _ := by + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun e _ => (Finset.sum_smul).symm + +include hT in +/-- One averaged round at orbit level: an element of weight zero along all three + axes expanded over the orbit sums of the representatives re-expands through the + row-orbit sums of the boost average — the matrix of the boost average acting on the + orbit-sum span. -/ +lemma eq_sum_boostAverageTransition_of_mem_rotationSubset {x : B} + (c : (Fin 4 → Fin 1 ⊕ Fin 3) → ℂ) + (hx : x = ∑ d ∈ rotationSubset, c d • rotationOrbitSum (T := T) d) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ d ∈ rotationSubset, (∑ e ∈ rotationSubset, + ((∑ d' ∈ rotationIndexSet d, boostAverageTransition d' e : ℚ) : ℂ) * c e) + • rotationOrbitSum (T := T) d := by + have hxT := hx.trans (sum_rotationSubset_smul_rotationOrbitSum (T := T) c) + have hround := hT.eq_sum_boostAverageTransition_smul _ hxT hw + rw [hround, sum_rotationSubset_smul_rotationOrbitSum (T := T)] + refine Finset.sum_congr rfl fun d _ => ?_ + congr 1 + calc ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, ((boostAverageTransition d e : ℚ) : ℂ) + * (∑ r ∈ rotationSubset, c r * ((rotationOrbitCoeff r e : ℤ) : ℂ)) + = ∑ r ∈ rotationSubset, c r * ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + ((boostAverageTransition d e : ℚ) : ℂ) * ((rotationOrbitCoeff r e : ℤ) : ℂ) := by + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun r _ => Finset.sum_congr rfl fun e _ => ?_ + ring + _ = ∑ r ∈ rotationSubset, c r + * ((boostAverageTransition d r + boostAverageTransition d (fun s => cycDir (r s)) + + boostAverageTransition d (fun s => cycDir (cycDir (r s))) : ℚ) : ℂ) := by + refine Finset.sum_congr rfl fun r _ => ?_ + congr 1 + push_cast + simp [rotationOrbitCoeff, apply_ite (fun n : ℤ => (n : ℂ)), mul_add, mul_ite, + Finset.sum_add_distrib, Finset.sum_ite_eq'] + _ = ∑ r ∈ rotationSubset, c r * ((∑ ρ ∈ rotationSubset, + (∑ d' ∈ rotationIndexSet ρ, boostAverageTransition d' r) + * ((rotationOrbitCoeff ρ d : ℤ) : ℚ) : ℚ) : ℂ) := by + refine Finset.sum_congr rfl fun r hr => ?_ + rw [boostAverageTransition_orbit_eq r + (isPairedOrDistinct_of_mem_rotationSubset r hr) d] + _ = _ := by + push_cast + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun r _ => ?_ + rw [Finset.sum_mul] + refine Finset.sum_congr rfl fun e _ => ?_ + ring + +/-! + +## G. The boost average as an integer `22 × 22` matrix + +The representatives are enumerated by `Fin 22`; `48` times the row-orbit sums of the +boost average form an integer matrix computed directly from the integer mirrors. + +## G.1. Enumerating the representatives + +-/ + +/-- The enumeration of the `22` canonical orbit representatives, in the order of + `rotationSubset`. -/ +def orbitRep : Fin 22 → Fin 4 → Fin 1 ⊕ Fin 3 := + ![![Sum.inl 0, Sum.inl 0, Sum.inl 0, Sum.inl 0], + ![Sum.inl 0, Sum.inl 0, Sum.inr 0, Sum.inr 0], + ![Sum.inl 0, Sum.inr 0, Sum.inl 0, Sum.inr 0], + ![Sum.inl 0, Sum.inr 0, Sum.inr 0, Sum.inl 0], + ![Sum.inl 0, Sum.inr 0, Sum.inr 1, Sum.inr 2], + ![Sum.inl 0, Sum.inr 0, Sum.inr 2, Sum.inr 1], + ![Sum.inr 0, Sum.inl 0, Sum.inl 0, Sum.inr 0], + ![Sum.inr 0, Sum.inl 0, Sum.inr 0, Sum.inl 0], + ![Sum.inr 0, Sum.inl 0, Sum.inr 1, Sum.inr 2], + ![Sum.inr 0, Sum.inl 0, Sum.inr 2, Sum.inr 1], + ![Sum.inr 0, Sum.inr 0, Sum.inl 0, Sum.inl 0], + ![Sum.inr 0, Sum.inr 0, Sum.inr 0, Sum.inr 0], + ![Sum.inr 0, Sum.inr 0, Sum.inr 1, Sum.inr 1], + ![Sum.inr 0, Sum.inr 0, Sum.inr 2, Sum.inr 2], + ![Sum.inr 0, Sum.inr 1, Sum.inl 0, Sum.inr 2], + ![Sum.inr 0, Sum.inr 1, Sum.inr 0, Sum.inr 1], + ![Sum.inr 0, Sum.inr 1, Sum.inr 1, Sum.inr 0], + ![Sum.inr 0, Sum.inr 1, Sum.inr 2, Sum.inl 0], + ![Sum.inr 0, Sum.inr 2, Sum.inl 0, Sum.inr 1], + ![Sum.inr 0, Sum.inr 2, Sum.inr 0, Sum.inr 2], + ![Sum.inr 0, Sum.inr 2, Sum.inr 1, Sum.inl 0], + ![Sum.inr 0, Sum.inr 2, Sum.inr 2, Sum.inr 0]] + +/-- The enumeration of the representatives is injective. -/ +lemma orbitRep_injective : Function.Injective orbitRep := by + decide +kernel + +/-- The set of representatives is the image of the enumeration. -/ +lemma rotationSubset_eq_image : + rotationSubset = Finset.univ.image orbitRep := by + decide +kernel + +/-- Sums over the representatives reindexed through the enumeration. -/ +lemma sum_rotationSubset {β : Type*} [AddCommMonoid β] + (f : (Fin 4 → Fin 1 ⊕ Fin 3) → β) : + ∑ d ∈ rotationSubset, f d = ∑ k : Fin 22, f (orbitRep k) := by + rw [rotationSubset_eq_image, Finset.sum_image fun k _ k' _ h => orbitRep_injective h] + +/-! + +## G.2. The closed form of the integer weight-zero transition + +The balanced-sector convolution collapses slot by slot, by induction on the slots: +transverse slots contribute a diagonal `2`, sector-incompatible slots kill the entry, +and the null slots fold their signs through `balancedSymZ`. + +-/ + +/-- Integer mirror of `slotTransition`: twice its value, in closed form. On the two + null sectors it is supported on the axis-`i` block `{t, xᵢ}` — the raising sector + `κ = 0` carries the sign matrix `[[1, -1], [-1, 1]]`, the lowering sector `κ = 1` the + all-ones matrix — and the transverse sector `κ = 2` is twice the identity on the two + transverse directions. `slotTransitionZ_eq_sum` recovers it as the + `lightConeCoeffInvZ · lightConeCoeffZ` composite summed over the sector. -/ +def slotTransitionZ (i : Fin 3) (κ : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : ℤ := + if κ = 2 then (if μ = ν ∧ μ ≠ Sum.inl 0 ∧ μ ≠ Sum.inr i then 2 else 0) + else if (μ = Sum.inl 0 ∨ μ = Sum.inr i) ∧ (ν = Sum.inl 0 ∨ ν = Sum.inr i) then + (if κ = 0 then (if μ = Sum.inr i then -1 else 1) * (if ν = Sum.inr i then -1 else 1) + else 1) + else 0 + +/-- The closed-form integer slot matrix is the sector sum of the coefficient + composites. -/ +lemma slotTransitionZ_eq_sum (i : Fin 3) (κ : Fin 3) (μ ν : Fin 1 ⊕ Fin 3) : + slotTransitionZ i κ μ ν + = ∑ κ' ∈ Finset.univ.filter (fun κ' : Fin 4 => sectorIndex κ' = κ), + lightConeCoeffInvZ i μ κ' * lightConeCoeffZ i κ' ν := by + decide +revert + +/-- A direction letter lies in the axis-`i` null sector: time or the axis direction. -/ +def InSector (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Prop := μ = Sum.inl 0 ∨ μ = Sum.inr i + +instance (i : Fin 3) (μ : Fin 1 ⊕ Fin 3) : Decidable (InSector i μ) := + inferInstanceAs (Decidable (_ ∨ _)) + +/-- The balanced fold of a list of signs: the sum, over the raise/lower assignments of + the listed slots whose weights total `m`, of the products of the raising signs. -/ +def balancedSymZ : ℤ → List ℤ → ℤ + | m, [] => if m = 0 then 1 else 0 + | m, ε :: l => ε * balancedSymZ (m - 2) l + balancedSymZ (m + 2) l + +/-- The null-swap signs of the null-sector slots, in slot order. -/ +def sectorSigns (i : Fin 3) : {n : ℕ} → (d e : Fin n → Fin 1 ⊕ Fin 3) → List ℤ + | 0, _, _ => [] + | _ + 1, d, e => + if InSector i (e 0) then + nuSignZ i (e 0) (d 0) :: sectorSigns i (Fin.tail d) (Fin.tail e) + else sectorSigns i (Fin.tail d) (Fin.tail e) + +/-- The number of slots outside the axis-`i` null sector. -/ +def transverseCount (i : Fin 3) : {n : ℕ} → (Fin n → Fin 1 ⊕ Fin 3) → ℕ + | 0, _ => 0 + | _ + 1, e => (if InSector i (e 0) then 0 else 1) + transverseCount i (Fin.tail e) + +/-- The weight-`m` integer transition over `n` slots, for the slot-peeling induction. -/ +def weightTransitionZAux (i : Fin 3) {n : ℕ} (d e : Fin n → Fin 1 ⊕ Fin 3) (m : ℤ) : ℤ := + ∑ w : Fin n → Fin 3, if (∑ s, sectorWeight (w s)) = m then + ∏ s, slotTransitionZ i (w s) (e s) (d s) else 0 + +lemma slotTransitionZ_raise_of_sector {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hμ : InSector i μ) (hν : InSector i ν) : + slotTransitionZ i 0 μ ν = nuSignZ i μ ν := by + rw [slotTransitionZ, nuSignZ, if_neg (by simp), if_pos ⟨hμ, hν⟩, if_pos rfl] + +lemma slotTransitionZ_lower_of_sector {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hμ : InSector i μ) (hν : InSector i ν) : + slotTransitionZ i 1 μ ν = 1 := by + rw [slotTransitionZ, if_neg (by simp), if_pos ⟨hμ, hν⟩, if_neg (by simp)] + +lemma slotTransitionZ_transverse_of_sector {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hμ : InSector i μ) : + slotTransitionZ i 2 μ ν = 0 := by + rw [slotTransitionZ, if_pos rfl, if_neg] + rintro ⟨-, h1, h2⟩ + rcases hμ with h | h + exacts [h1 h, h2 h] + +lemma slotTransitionZ_null_of_not_sector_left {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hμ : ¬InSector i μ) (κ : Fin 3) (hκ : κ ≠ 2) : + slotTransitionZ i κ μ ν = 0 := by + rw [slotTransitionZ, if_neg hκ, if_neg] + exact fun h => hμ h.1 + +lemma slotTransitionZ_null_of_not_sector_right {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hν : ¬InSector i ν) (κ : Fin 3) (hκ : κ ≠ 2) : + slotTransitionZ i κ μ ν = 0 := by + rw [slotTransitionZ, if_neg hκ, if_neg] + exact fun h => hν h.2 + +lemma slotTransitionZ_transverse_of_not_sector {i : Fin 3} {μ ν : Fin 1 ⊕ Fin 3} + (hμ : ¬InSector i μ) : + slotTransitionZ i 2 μ ν = if μ = ν then 2 else 0 := by + rw [slotTransitionZ, if_pos rfl] + simp only [InSector, not_or] at hμ + by_cases h : μ = ν + · rw [if_pos ⟨h, hμ.1, hμ.2⟩, if_pos h] + · rw [if_neg (fun hc => h hc.1), if_neg h] + +lemma weightTransitionZAux_nil (i : Fin 3) (d e : Fin 0 → Fin 1 ⊕ Fin 3) (m : ℤ) : + weightTransitionZAux i d e m = if m = 0 then 1 else 0 := by + rw [weightTransitionZAux, Fintype.sum_unique] + simp [eq_comm] + +lemma weightTransitionZAux_succ (i : Fin 3) {n : ℕ} (d e : Fin (n + 1) → Fin 1 ⊕ Fin 3) + (m : ℤ) : + weightTransitionZAux i d e m + = slotTransitionZ i 0 (e 0) (d 0) + * weightTransitionZAux i (Fin.tail d) (Fin.tail e) (m - 2) + + slotTransitionZ i 1 (e 0) (d 0) + * weightTransitionZAux i (Fin.tail d) (Fin.tail e) (m + 2) + + slotTransitionZ i 2 (e 0) (d 0) + * weightTransitionZAux i (Fin.tail d) (Fin.tail e) m := by + rw [weightTransitionZAux, + ← Equiv.sum_comp (Fin.consEquiv (fun _ : Fin (n + 1) => Fin 3)), Fintype.sum_prod_type] + simp only [Fin.consEquiv_apply, Fin.sum_univ_succ, Fin.prod_univ_succ, Fin.cons_zero, + Fin.cons_succ, Fin.sum_univ_zero, add_zero] + simp only [show sectorWeight 0 = 2 from rfl, show sectorWeight (Fin.succ 0) = -2 from rfl, + show sectorWeight ((Fin.succ 0).succ) = 0 from rfl] + rw [weightTransitionZAux, weightTransitionZAux, weightTransitionZAux, add_assoc] + congr 1 + · rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun w _ => by + rw [mul_ite, mul_zero] + exact if_congr (by omega) rfl rfl + · congr 1 + · rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun w _ => by + rw [mul_ite, mul_zero] + exact if_congr (by omega) rfl rfl + · rw [Finset.mul_sum] + exact Finset.sum_congr rfl fun w _ => by + rw [mul_ite, mul_zero] + exact if_congr (by omega) rfl rfl + +theorem weightTransitionZAux_eq_closed (i : Fin 3) : + ∀ {n : ℕ} (d e : Fin n → Fin 1 ⊕ Fin 3) (m : ℤ), + weightTransitionZAux i d e m + = if ∀ s, SameSlotSector i (e s) (d s) then + 2 ^ transverseCount i e * balancedSymZ m (sectorSigns i d e) + else 0 + | 0, d, e, m => by + rw [weightTransitionZAux_nil, if_pos (fun s => s.elim0)] + simp [transverseCount, sectorSigns, balancedSymZ] + | n + 1, d, e, m => by + rw [weightTransitionZAux_succ, + weightTransitionZAux_eq_closed i (Fin.tail d) (Fin.tail e) (m - 2), + weightTransitionZAux_eq_closed i (Fin.tail d) (Fin.tail e) (m + 2), + weightTransitionZAux_eq_closed i (Fin.tail d) (Fin.tail e) m] + simp only [Fin.forall_fin_succ] + by_cases htail : ∀ s : Fin n, SameSlotSector i (Fin.tail e s) (Fin.tail d s) + case neg => + rw [if_neg htail, if_neg htail, if_neg htail, if_neg (fun h => htail h.2)] + ring + case pos => + rw [if_pos htail, if_pos htail, if_pos htail] + by_cases he : InSector i (e 0) + · by_cases hd : InSector i (d 0) + · rw [slotTransitionZ_raise_of_sector he hd, slotTransitionZ_lower_of_sector he hd, + slotTransitionZ_transverse_of_sector he, if_pos ⟨Or.inl ⟨he, hd⟩, htail⟩] + simp only [transverseCount, if_pos he, zero_add, sectorSigns, balancedSymZ] + ring + · rw [slotTransitionZ_null_of_not_sector_right hd 0 (by simp), + slotTransitionZ_null_of_not_sector_right hd 1 (by simp), + slotTransitionZ_transverse_of_sector he, if_neg ?_] + · ring + · rintro ⟨⟨-, hd'⟩ | heq, -⟩ + exacts [hd hd', hd (heq ▸ he)] + · by_cases heq : e 0 = d 0 + · rw [slotTransitionZ_null_of_not_sector_left he 0 (by simp), + slotTransitionZ_null_of_not_sector_left he 1 (by simp), + slotTransitionZ_transverse_of_not_sector he, if_pos heq, + if_pos ⟨Or.inr heq, htail⟩] + simp only [transverseCount, if_neg he, sectorSigns] + rw [pow_add, pow_one] + ring + · rw [slotTransitionZ_null_of_not_sector_left he 0 (by simp), + slotTransitionZ_null_of_not_sector_left he 1 (by simp), + slotTransitionZ_transverse_of_not_sector he, if_neg heq, if_neg ?_] + · ring + · rintro ⟨⟨he', -⟩ | h, -⟩ + exacts [he he', heq h] + +/-- Integer mirror of the weight-zero transition: sixteen times its value, in closed + form — zero unless every slot is sector-compatible, and otherwise a power of two from + the transverse slots times the balanced symmetric fold of the null-sector signs. + `weightZeroTransitionZ_eq_sum_sector` recovers the balanced-sector convolution of the + integer slot matrices. -/ +def weightZeroTransitionZ (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : ℤ := + if ∀ s, SameSlotSector i (e s) (d s) then + 2 ^ transverseCount i e * balancedSymZ 0 (sectorSigns i d e) + else 0 + +/-- The closed-form integer weight-zero transition as the balanced-sector convolution + of the integer slot matrices. -/ +lemma weightZeroTransitionZ_eq_sum_sector (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + weightZeroTransitionZ i d e + = ∑ w ∈ Finset.univ.filter (fun w : Fin 4 → Fin 3 => (∑ s, sectorWeight (w s)) = 0), + ∏ s, slotTransitionZ i (w s) (e s) (d s) := by + rw [weightZeroTransitionZ, ← weightTransitionZAux_eq_closed, weightTransitionZAux, + Finset.sum_filter] + + +/-- The integer weight-zero transition as a light-cone sum. -/ +lemma weightZeroTransitionZ_eq_sum_lightCone (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + weightZeroTransitionZ i d e + = ∑ c ∈ Finset.univ.filter (fun c : Fin 4 → Fin 4 => (∑ s, lightConeWeight (c s)) = 0), + ∏ s, lightConeCoeffInvZ i (e s) (c s) * lightConeCoeffZ i (c s) (d s) := by + rw [weightZeroTransitionZ_eq_sum_sector] + simp only [slotTransitionZ_eq_sum] + exact (sum_weightZero_eq_sum_sector + (fun s κ => lightConeCoeffInvZ i (e s) κ * lightConeCoeffZ i κ (d s))).symm + + + +/-- The integer mirror casts to sixteen times the weight-zero transition. -/ +lemma coe_weightZeroTransitionZ (i : Fin 3) (d e : Fin 4 → Fin 1 ⊕ Fin 3) : + ((weightZeroTransitionZ i d e : ℤ) : ℚ) = 16 * weightZeroTransition i d e := by + rw [weightZeroTransitionZ_eq_sum_lightCone, weightZeroTransition_eq_sum_lightCone] + push_cast + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun c _ => ?_ + calc ∏ s, ((lightConeCoeffInvZ i (e s) (c s) : ℤ) : ℚ) + * ((lightConeCoeffZ i (c s) (d s) : ℤ) : ℚ) + = ∏ s, 2 * (lightConeCoeffInvQ i (e s) (c s) + * ((lightConeCoeffZ i (c s) (d s) : ℤ) : ℚ)) := by + refine Finset.prod_congr rfl fun s _ => ?_ + rw [coe_lightConeCoeffInvZ] + ring + _ = 16 * ∏ s, lightConeCoeffInvQ i (e s) (c s) + * ((lightConeCoeffZ i (c s) (d s) : ℤ) : ℚ) := by + rw [Finset.prod_mul_distrib, Finset.prod_const] + norm_num [Finset.card_univ] + +/-! + +## G.3. The integer matrix of the averaged round + +-/ + +/-- The boost average on the orbit-sum span, as an integer matrix: `48` times the + row-orbit sums of the boost average between representatives, in explicit form. + `boostAverageOrbitZ_eq_sum` identifies the entries with the row-orbit sums of the + integer weight-zero transitions. -/ +def boostAverageOrbitZ : Matrix (Fin 22) (Fin 22) ℤ := + !![18, -2, -2, -2, 0, 0, -2, -2, 0, 0, -2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0; + -6, 22, -2, -2, 0, 0, -2, -2, 0, 0, 6, -2, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0; + -6, -2, 22, -2, 0, 0, -2, 6, 0, 0, -2, -2, 0, 0, 0, -8, 0, 0, 0, -8, 0, 0; + -6, -2, -2, 22, 0, 0, 6, -2, 0, 0, -2, -2, 0, 0, 0, 0, -8, 0, 0, 0, 0, -8; + 0, 0, 0, 0, 24, 0, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, -8, 0, 0, 0; + 0, 0, 0, 0, 0, 24, 0, 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, -8, 0; + -6, -2, -2, 6, 0, 0, 22, -2, 0, 0, -2, -2, 0, 0, 0, 0, -8, 0, 0, 0, 0, -8; + -6, -2, 6, -2, 0, 0, -2, 22, 0, 0, -2, -2, 0, 0, 0, -8, 0, 0, 0, -8, 0, 0; + 0, 0, 0, 0, -8, 0, 0, 0, 24, 0, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, -8, 0; + 0, 0, 0, 0, 0, -8, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, -8, -8, 0, 0, 0; + -6, 6, -2, -2, 0, 0, -2, -2, 0, 0, 22, -2, -8, -8, 0, 0, 0, 0, 0, 0, 0, 0; + 18, -2, -2, -2, 0, 0, -2, -2, 0, 0, -2, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0; + 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0; + 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0; + 0, 0, 0, 0, 0, -8, 0, 0, -8, 0, 0, 0, 0, 0, 24, 0, 0, -8, 0, 0, 0, 0; + 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0; + 0, 0, 0, -8, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0; + 0, 0, 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 24, 0, 0, 0, 0; + 0, 0, 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, -8, 0; + 0, 0, -8, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0; + 0, 0, 0, 0, 0, -8, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, -8, 0, 24, 0; + 0, 0, 0, -8, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32] + +set_option maxRecDepth 40000 in +/-- The entries of the explicit boost-average matrix are the row-orbit sums of the + integer weight-zero transitions. -/ +lemma boostAverageOrbitZ_eq_sum : ∀ k l : Fin 22, + boostAverageOrbitZ k l = ∑ d' ∈ rotationIndexSet (orbitRep k), + ∑ i : Fin 3, weightZeroTransitionZ i d' (orbitRep l) := by + decide +kernel + +/-- The integer matrix casts to `48` times the row-orbit sums of the boost average. -/ +lemma coe_boostAverageOrbitZ (k l : Fin 22) : + ((boostAverageOrbitZ k l : ℤ) : ℚ) + = 48 * ∑ d' ∈ rotationIndexSet (orbitRep k), + boostAverageTransition d' (orbitRep l) := by + simp only [boostAverageOrbitZ_eq_sum] + push_cast + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun d' _ => ?_ + calc ∑ i : Fin 3, ((weightZeroTransitionZ i d' (orbitRep l) : ℤ) : ℚ) + = ∑ i : Fin 3, 16 * weightZeroTransition i d' (orbitRep l) := + Finset.sum_congr rfl fun i _ => coe_weightZeroTransitionZ i d' (orbitRep l) + _ = 48 * boostAverageTransition d' (orbitRep l) := by + simp only [boostAverageTransition, Matrix.of_apply] + rw [← Finset.mul_sum] + ring + +include hT in +/-- One averaged round at orbit level, integer form: over the enumerated + representatives, an averaged round acts by the integer matrix `boostAverageOrbitZ` + with the overall `48⁻¹` normalisation. -/ +lemma eq_sum_boostAverageOrbitZ_smul {x : B} (c : Fin 22 → ℂ) + (hx : x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k)) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ k, ((48 : ℂ)⁻¹ * ∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) * c l) + • rotationOrbitSum (T := T) (orbitRep k) := by + have hcS_rep : ∀ k : Fin 22, + (∑ k' : Fin 22, if orbitRep k' = orbitRep k then c k' else 0) = c k := by + intro k + simp [orbitRep_injective.eq_iff] + have hxS : x = ∑ d ∈ rotationSubset, + (∑ k' : Fin 22, if orbitRep k' = d then c k' else 0) + • rotationOrbitSum (T := T) d := by + calc x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k) := hx + _ = ∑ k, (∑ k' : Fin 22, if orbitRep k' = orbitRep k then c k' else 0) + • rotationOrbitSum (T := T) (orbitRep k) := + Finset.sum_congr rfl fun k _ => by rw [hcS_rep k] + _ = _ := (sum_rotationSubset (fun d => (∑ k' : Fin 22, + if orbitRep k' = d then c k' else 0) • rotationOrbitSum (T := T) d)).symm + have hR := hT.eq_sum_boostAverageTransition_of_mem_rotationSubset _ hxS hw + rw [hR, sum_rotationSubset] + refine Finset.sum_congr rfl fun k _ => ?_ + congr 1 + rw [sum_rotationSubset (fun e => ((∑ d' ∈ rotationIndexSet (orbitRep k), + boostAverageTransition d' e : ℚ) : ℂ) + * ∑ k' : Fin 22, if orbitRep k' = e then c k' else 0)] + rw [Finset.mul_sum] + refine Finset.sum_congr rfl fun l _ => ?_ + rw [hcS_rep l] + have hb := congrArg (fun q : ℚ => (q : ℂ)) (coe_boostAverageOrbitZ k l) + push_cast at hb + push_cast + rw [hb] + ring + +include hT in +/-- Iterated averaged rounds at orbit level: `n` rounds act by the `n`-th power of + the integer matrix with the `48⁻ⁿ` normalisation. -/ +lemma eq_sum_pow_boostAverageOrbitZ_smul {x : B} (c : Fin 22 → ℂ) + (hx : x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k)) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) (n : ℕ) : + x = ∑ k, (((48 : ℂ) ^ n)⁻¹ * ∑ l, (((boostAverageOrbitZ ^ n) k l : ℤ) : ℂ) * c l) + • rotationOrbitSum (T := T) (orbitRep k) := by + induction n with + | zero => + rw [hx] + refine Finset.sum_congr rfl fun k _ => ?_ + congr 1 + rw [pow_zero, pow_zero] + simp [Matrix.one_apply, apply_ite (fun q : ℤ => (q : ℂ)), ite_mul, Finset.sum_ite_eq] + | succ n ih => + rw [hT.eq_sum_boostAverageOrbitZ_smul + (fun k => ((48 : ℂ) ^ n)⁻¹ * ∑ l, (((boostAverageOrbitZ ^ n) k l : ℤ) : ℂ) * c l) + ih hw] + refine Finset.sum_congr rfl fun k _ => ?_ + congr 1 + calc (48 : ℂ)⁻¹ * ∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) + * (((48 : ℂ) ^ n)⁻¹ * ∑ m, (((boostAverageOrbitZ ^ n) l m : ℤ) : ℂ) * c m) + = ((48 : ℂ) ^ (n + 1))⁻¹ * ∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) + * ∑ m, (((boostAverageOrbitZ ^ n) l m : ℤ) : ℂ) * c m := by + rw [Finset.mul_sum, Finset.mul_sum] + refine Finset.sum_congr rfl fun l _ => ?_ + rw [pow_succ] + field_simp + _ = ((48 : ℂ) ^ (n + 1))⁻¹ * ∑ m, (((boostAverageOrbitZ * boostAverageOrbitZ ^ n) k m + : ℤ) : ℂ) * c m := by + congr 1 + calc ∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) + * ∑ m, (((boostAverageOrbitZ ^ n) l m : ℤ) : ℂ) * c m + = ∑ l, ∑ m, ((boostAverageOrbitZ k l : ℤ) : ℂ) + * ((((boostAverageOrbitZ ^ n) l m : ℤ) : ℂ) * c m) := + Finset.sum_congr rfl fun l _ => by rw [Finset.mul_sum] + _ = ∑ m, (∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) + * (((boostAverageOrbitZ ^ n) l m : ℤ) : ℂ)) * c m := by + rw [Finset.sum_comm] + refine Finset.sum_congr rfl fun m _ => ?_ + rw [Finset.sum_mul] + exact Finset.sum_congr rfl fun l _ => (mul_assoc _ _ _).symm + _ = ∑ m, (((boostAverageOrbitZ * boostAverageOrbitZ ^ n) k m : ℤ) : ℂ) * c m := by + refine Finset.sum_congr rfl fun m _ => ?_ + congr 1 + rw [Matrix.mul_apply] + push_cast + rfl + _ = ((48 : ℂ) ^ (n + 1))⁻¹ + * ∑ m, (((boostAverageOrbitZ ^ (n + 1)) k m : ℤ) : ℂ) * c m := by + rw [← pow_succ' boostAverageOrbitZ n] + +/-! + +## H. The certificate polynomial and the contraction projector + +On the orbit-sum span the boost average has rational spectrum, with eigenvalue `1` +exactly on the invariant contractions. The certificate polynomial +`λ(3λ-2)(3λ-1)(12λ²-11λ+1)` annihilates every other eigenvalue, so applied to the +iterated rounds it collapses them to the projector onto the invariant block. + +-/ + +/-- Twenty-four times the projector onto the invariant block: the integer matrix + `P` with `boostAverageOrbitZ * P = 48 • P` and `P * P = 24 • P`, so that `24⁻¹ • P` + projects the orbit-sum span onto the eigenvalue-`48` block — the invariant + contractions. -/ +def contractionProjectorZ : Matrix (Fin 22) (Fin 22) ℤ := + !![3, -1, -1, -1, 0, 0, -1, -1, 0, 0, -1, 3, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1; + -3, 5, -1, -1, 0, 0, -1, -1, 0, 0, 5, -3, -5, -5, 0, 1, 1, 0, 0, 1, 0, 1; + -3, -1, 5, -1, 0, 0, -1, 5, 0, 0, -1, -3, 1, 1, 0, -5, 1, 0, 0, -5, 0, 1; + -3, -1, -1, 5, 0, 0, 5, -1, 0, 0, -1, -3, 1, 1, 0, 1, -5, 0, 0, 1, 0, -5; + 0, 0, 0, 0, 3, -3, 0, 0, -3, 3, 0, 0, 0, 0, 3, 0, 0, -3, -3, 0, 3, 0; + 0, 0, 0, 0, -3, 3, 0, 0, 3, -3, 0, 0, 0, 0, -3, 0, 0, 3, 3, 0, -3, 0; + -3, -1, -1, 5, 0, 0, 5, -1, 0, 0, -1, -3, 1, 1, 0, 1, -5, 0, 0, 1, 0, -5; + -3, -1, 5, -1, 0, 0, -1, 5, 0, 0, -1, -3, 1, 1, 0, -5, 1, 0, 0, -5, 0, 1; + 0, 0, 0, 0, -3, 3, 0, 0, 3, -3, 0, 0, 0, 0, -3, 0, 0, 3, 3, 0, -3, 0; + 0, 0, 0, 0, 3, -3, 0, 0, -3, 3, 0, 0, 0, 0, 3, 0, 0, -3, -3, 0, 3, 0; + -3, 5, -1, -1, 0, 0, -1, -1, 0, 0, 5, -3, -5, -5, 0, 1, 1, 0, 0, 1, 0, 1; + 9, -3, -3, -3, 0, 0, -3, -3, 0, 0, -3, 9, 3, 3, 0, 3, 3, 0, 0, 3, 0, 3; + 3, -5, 1, 1, 0, 0, 1, 1, 0, 0, -5, 3, 5, 5, 0, -1, -1, 0, 0, -1, 0, -1; + 3, -5, 1, 1, 0, 0, 1, 1, 0, 0, -5, 3, 5, 5, 0, -1, -1, 0, 0, -1, 0, -1; + 0, 0, 0, 0, 3, -3, 0, 0, -3, 3, 0, 0, 0, 0, 3, 0, 0, -3, -3, 0, 3, 0; + 3, 1, -5, 1, 0, 0, 1, -5, 0, 0, 1, 3, -1, -1, 0, 5, -1, 0, 0, 5, 0, -1; + 3, 1, 1, -5, 0, 0, -5, 1, 0, 0, 1, 3, -1, -1, 0, -1, 5, 0, 0, -1, 0, 5; + 0, 0, 0, 0, -3, 3, 0, 0, 3, -3, 0, 0, 0, 0, -3, 0, 0, 3, 3, 0, -3, 0; + 0, 0, 0, 0, -3, 3, 0, 0, 3, -3, 0, 0, 0, 0, -3, 0, 0, 3, 3, 0, -3, 0; + 3, 1, -5, 1, 0, 0, 1, -5, 0, 0, 1, 3, -1, -1, 0, 5, -1, 0, 0, 5, 0, -1; + 0, 0, 0, 0, 3, -3, 0, 0, -3, 3, 0, 0, 0, 0, 3, 0, 0, -3, -3, 0, 3, 0; + 3, 1, 1, -5, 0, 0, -5, 1, 0, 0, 1, 3, -1, -1, 0, -1, 5, 0, 0, -1, 0, 5] + +/-- The certificate polynomial applied to the boost average: the integer-scaled + annihilator of the non-invariant blocks, `μ(μ-32)(μ-16)(μ²-44μ+192)` at + `μ = boostAverageOrbitZ` — the polynomial `λ(3λ-2)(3λ-1)(12λ²-11λ+1)` of the + normalised average `λ = μ/48`, cleared of denominators. -/ +def Q : Matrix (Fin 22) (Fin 22) ℤ := + boostAverageOrbitZ * (boostAverageOrbitZ - 32) * (boostAverageOrbitZ - 16) * + (boostAverageOrbitZ * boostAverageOrbitZ - 44 • boostAverageOrbitZ + 192) + +set_option maxRecDepth 40000 in +/-- The certificate collapses to the projector: applying the certificate polynomial + to the boost average yields `393216` times `contractionProjectorZ`. Verified through + materialised intermediate products, so each kernel step is a single multiplication of + explicit integer matrices. -/ +lemma Q_explicit : Q = (393216 : ℤ) • contractionProjectorZ := by + have h1 : boostAverageOrbitZ * (boostAverageOrbitZ - 32) + = (!![-72, -24, -24, -24, 0, 0, -24, -24, 0, 0, -24, 168, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + -72, -24, -24, -24, 0, 0, -24, -24, 0, 0, 232, -88, -224, -224, 0, 32, 32, 0, 0, 32, 0, 32; + -72, -24, -24, -24, 0, 0, -24, 232, 0, 0, -24, -88, 32, 32, 0, -224, 32, 0, 0, -224, 0, 32; + -72, -24, -24, -24, 0, 0, 232, -24, 0, 0, -24, -88, 32, 32, 0, 32, -224, 0, 0, 32, 0, -224; + 0, 0, 0, 0, 0, 0, 0, 0, -128, 128, 0, 0, 0, 0, 128, 0, 0, -128, -128, 0, 128, 0; + 0, 0, 0, 0, 0, 0, 0, 0, 128, -128, 0, 0, 0, 0, -128, 0, 0, 128, 128, 0, -128, 0; + -72, -24, -24, 232, 0, 0, -24, -24, 0, 0, -24, -88, 32, 32, 0, 32, -224, 0, 0, 32, 0, -224; + -72, -24, 232, -24, 0, 0, -24, -24, 0, 0, -24, -88, 32, 32, 0, -224, 32, 0, 0, -224, 0, 32; + 0, 0, 0, 0, -128, 128, 0, 0, 0, 0, 0, 0, 0, 0, -128, 0, 0, 128, 128, 0, -128, 0; + 0, 0, 0, 0, 128, -128, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, -128, -128, 0, 128, 0; + -72, 232, -24, -24, 0, 0, -24, -24, 0, 0, -24, -88, -224, -224, 0, 32, 32, 0, 0, 32, 0, 32; + 504, -88, -88, -88, 0, 0, -88, -88, 0, 0, -88, 360, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 96, -224, 32, 32, 0, 0, 32, 32, 0, 0, -224, 32, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 96, -224, 32, 32, 0, 0, 32, 32, 0, 0, -224, 32, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 0, 0, 0, 0, 128, -128, 0, 0, -128, 128, 0, 0, 0, 0, 0, 0, 0, -128, 0, 0, 128, 0; + 96, 32, -224, 32, 0, 0, 32, -224, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, 128, 0, 0; + 96, 32, 32, -224, 0, 0, -224, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, 128; + 0, 0, 0, 0, -128, 128, 0, 0, 128, -128, 0, 0, 0, 0, -128, 0, 0, 0, 128, 0, 0, 0; + 0, 0, 0, 0, -128, 128, 0, 0, 128, -128, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, -128, 0; + 96, 32, -224, 32, 0, 0, 32, -224, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, 128, 0, 0; + 0, 0, 0, 0, 128, -128, 0, 0, -128, 128, 0, 0, 0, 0, 128, 0, 0, 0, -128, 0, 0, 0; + 96, 32, 32, -224, 0, 0, -224, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, 128] : Matrix (Fin 22) (Fin 22) ℤ) := by + ext k l + revert k l + decide +kernel + have h2 : (!![-72, -24, -24, -24, 0, 0, -24, -24, 0, 0, -24, 168, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + -72, -24, -24, -24, 0, 0, -24, -24, 0, 0, 232, -88, -224, -224, 0, 32, 32, 0, 0, 32, 0, 32; + -72, -24, -24, -24, 0, 0, -24, 232, 0, 0, -24, -88, 32, 32, 0, -224, 32, 0, 0, -224, 0, 32; + -72, -24, -24, -24, 0, 0, 232, -24, 0, 0, -24, -88, 32, 32, 0, 32, -224, 0, 0, 32, 0, -224; + 0, 0, 0, 0, 0, 0, 0, 0, -128, 128, 0, 0, 0, 0, 128, 0, 0, -128, -128, 0, 128, 0; + 0, 0, 0, 0, 0, 0, 0, 0, 128, -128, 0, 0, 0, 0, -128, 0, 0, 128, 128, 0, -128, 0; + -72, -24, -24, 232, 0, 0, -24, -24, 0, 0, -24, -88, 32, 32, 0, 32, -224, 0, 0, 32, 0, -224; + -72, -24, 232, -24, 0, 0, -24, -24, 0, 0, -24, -88, 32, 32, 0, -224, 32, 0, 0, -224, 0, 32; + 0, 0, 0, 0, -128, 128, 0, 0, 0, 0, 0, 0, 0, 0, -128, 0, 0, 128, 128, 0, -128, 0; + 0, 0, 0, 0, 128, -128, 0, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, -128, -128, 0, 128, 0; + -72, 232, -24, -24, 0, 0, -24, -24, 0, 0, -24, -88, -224, -224, 0, 32, 32, 0, 0, 32, 0, 32; + 504, -88, -88, -88, 0, 0, -88, -88, 0, 0, -88, 360, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 96, -224, 32, 32, 0, 0, 32, 32, 0, 0, -224, 32, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 96, -224, 32, 32, 0, 0, 32, 32, 0, 0, -224, 32, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 0, 0, 0, 0, 128, -128, 0, 0, -128, 128, 0, 0, 0, 0, 0, 0, 0, -128, 0, 0, 128, 0; + 96, 32, -224, 32, 0, 0, 32, -224, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, 128, 0, 0; + 96, 32, 32, -224, 0, 0, -224, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, 128; + 0, 0, 0, 0, -128, 128, 0, 0, 128, -128, 0, 0, 0, 0, -128, 0, 0, 0, 128, 0, 0, 0; + 0, 0, 0, 0, -128, 128, 0, 0, 128, -128, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, -128, 0; + 96, 32, -224, 32, 0, 0, 32, -224, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, 128, 0, 0; + 0, 0, 0, 0, 128, -128, 0, 0, -128, 128, 0, 0, 0, 0, 128, 0, 0, 0, -128, 0, 0, 0; + 96, 32, 32, -224, 0, 0, -224, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, 128] : Matrix (Fin 22) (Fin 22) ℤ) + * (boostAverageOrbitZ - 16) + = (!![3744, -800, -800, -800, 0, 0, -800, -800, 0, 0, -800, 3552, 896, 896, 0, 896, 896, 0, 0, 896, 0, 896; + -2400, 5344, -800, -800, 0, 0, -800, -800, 0, 0, 5344, -2592, -5248, -5248, 0, 896, 896, 0, 0, 896, 0, 896; + -2400, -800, 5344, -800, 0, 0, -800, 5344, 0, 0, -800, -2592, 896, 896, 0, -5248, 896, 0, 0, -5248, 0, 896; + -2400, -800, -800, 5344, 0, 0, 5344, -800, 0, 0, -800, -2592, 896, 896, 0, 896, -5248, 0, 0, 896, 0, -5248; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + -2400, -800, -800, 5344, 0, 0, 5344, -800, 0, 0, -800, -2592, 896, 896, 0, 896, -5248, 0, 0, 896, 0, -5248; + -2400, -800, 5344, -800, 0, 0, -800, 5344, 0, 0, -800, -2592, 896, 896, 0, -5248, 896, 0, 0, -5248, 0, 896; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + -2400, 5344, -800, -800, 0, 0, -800, -800, 0, 0, 5344, -2592, -5248, -5248, 0, 896, 896, 0, 0, 896, 0, 896; + 10656, -2592, -2592, -2592, 0, 0, -2592, -2592, 0, 0, -2592, 12000, 1920, 1920, 0, 1920, 1920, 0, 0, 1920, 0, 1920; + 2688, -5248, 896, 896, 0, 0, 896, 896, 0, 0, -5248, 1920, 5632, 5632, 0, -512, -512, 0, 0, -512, 0, -512; + 2688, -5248, 896, 896, 0, 0, 896, 896, 0, 0, -5248, 1920, 5632, 5632, 0, -512, -512, 0, 0, -512, 0, -512; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 2688, 896, -5248, 896, 0, 0, 896, -5248, 0, 0, 896, 1920, -512, -512, 0, 5632, -512, 0, 0, 5632, 0, -512; + 2688, 896, 896, -5248, 0, 0, -5248, 896, 0, 0, 896, 1920, -512, -512, 0, -512, 5632, 0, 0, -512, 0, 5632; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 2688, 896, -5248, 896, 0, 0, 896, -5248, 0, 0, 896, 1920, -512, -512, 0, 5632, -512, 0, 0, 5632, 0, -512; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 2688, 896, 896, -5248, 0, 0, -5248, 896, 0, 0, 896, 1920, -512, -512, 0, -512, 5632, 0, 0, -512, 0, 5632] : Matrix (Fin 22) (Fin 22) ℤ) := by + ext k l + revert k l + decide +kernel + have h3 : boostAverageOrbitZ * boostAverageOrbitZ - 44 • boostAverageOrbitZ + 192 + = (!![-96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 0, -96, 0, 0, 0, 0, 0, 0, 0, 0, 160, -64, -128, -128, 0, 32, 32, 0, 0, 32, 0, 32; + 0, 0, -96, 0, 0, 0, 0, 160, 0, 0, 0, -64, 32, 32, 0, -128, 32, 0, 0, -128, 0, 32; + 0, 0, 0, -96, 0, 0, 160, 0, 0, 0, 0, -64, 32, 32, 0, 32, -128, 0, 0, 32, 0, -128; + 0, 0, 0, 0, -96, 0, 0, 0, -32, 128, 0, 0, 0, 0, 128, 0, 0, -32, -32, 0, 128, 0; + 0, 0, 0, 0, 0, -96, 0, 0, 128, -32, 0, 0, 0, 0, -32, 0, 0, 128, 128, 0, -32, 0; + 0, 0, 0, 160, 0, 0, -96, 0, 0, 0, 0, -64, 32, 32, 0, 32, -128, 0, 0, 32, 0, -128; + 0, 0, 160, 0, 0, 0, 0, -96, 0, 0, 0, -64, 32, 32, 0, -128, 32, 0, 0, -128, 0, 32; + 0, 0, 0, 0, -32, 128, 0, 0, -96, 0, 0, 0, 0, 0, -32, 0, 0, 128, 128, 0, -32, 0; + 0, 0, 0, 0, 128, -32, 0, 0, 0, -96, 0, 0, 0, 0, 128, 0, 0, -32, -32, 0, 128, 0; + 0, 160, 0, 0, 0, 0, 0, 0, 0, 0, -96, -64, -128, -128, 0, 32, 32, 0, 0, 32, 0, 32; + 288, -64, -64, -64, 0, 0, -64, -64, 0, 0, -64, 96, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 96, -128, 32, 32, 0, 0, 32, 32, 0, 0, -128, 32, -64, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 96, -128, 32, 32, 0, 0, 32, 32, 0, 0, -128, 32, 128, -64, 0, 0, 0, 0, 0, 0, 0, 0; + 0, 0, 0, 0, 128, -32, 0, 0, -32, 128, 0, 0, 0, 0, -96, 0, 0, -32, 0, 0, 128, 0; + 96, 32, -128, 32, 0, 0, 32, -128, 0, 0, 32, 32, 0, 0, 0, -64, 0, 0, 0, 128, 0, 0; + 96, 32, 32, -128, 0, 0, -128, 32, 0, 0, 32, 32, 0, 0, 0, 0, -64, 0, 0, 0, 0, 128; + 0, 0, 0, 0, -32, 128, 0, 0, 128, -32, 0, 0, 0, 0, -32, 0, 0, -96, 128, 0, 0, 0; + 0, 0, 0, 0, -32, 128, 0, 0, 128, -32, 0, 0, 0, 0, 0, 0, 0, 128, -96, 0, -32, 0; + 96, 32, -128, 32, 0, 0, 32, -128, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, -64, 0, 0; + 0, 0, 0, 0, 128, -32, 0, 0, -32, 128, 0, 0, 0, 0, 128, 0, 0, 0, -32, 0, -96, 0; + 96, 32, 32, -128, 0, 0, -128, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, -64] : Matrix (Fin 22) (Fin 22) ℤ) := by + ext k l + revert k l + decide +kernel + have h4 : (!![3744, -800, -800, -800, 0, 0, -800, -800, 0, 0, -800, 3552, 896, 896, 0, 896, 896, 0, 0, 896, 0, 896; + -2400, 5344, -800, -800, 0, 0, -800, -800, 0, 0, 5344, -2592, -5248, -5248, 0, 896, 896, 0, 0, 896, 0, 896; + -2400, -800, 5344, -800, 0, 0, -800, 5344, 0, 0, -800, -2592, 896, 896, 0, -5248, 896, 0, 0, -5248, 0, 896; + -2400, -800, -800, 5344, 0, 0, 5344, -800, 0, 0, -800, -2592, 896, 896, 0, 896, -5248, 0, 0, 896, 0, -5248; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + -2400, -800, -800, 5344, 0, 0, 5344, -800, 0, 0, -800, -2592, 896, 896, 0, 896, -5248, 0, 0, 896, 0, -5248; + -2400, -800, 5344, -800, 0, 0, -800, 5344, 0, 0, -800, -2592, 896, 896, 0, -5248, 896, 0, 0, -5248, 0, 896; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + -2400, 5344, -800, -800, 0, 0, -800, -800, 0, 0, 5344, -2592, -5248, -5248, 0, 896, 896, 0, 0, 896, 0, 896; + 10656, -2592, -2592, -2592, 0, 0, -2592, -2592, 0, 0, -2592, 12000, 1920, 1920, 0, 1920, 1920, 0, 0, 1920, 0, 1920; + 2688, -5248, 896, 896, 0, 0, 896, 896, 0, 0, -5248, 1920, 5632, 5632, 0, -512, -512, 0, 0, -512, 0, -512; + 2688, -5248, 896, 896, 0, 0, 896, 896, 0, 0, -5248, 1920, 5632, 5632, 0, -512, -512, 0, 0, -512, 0, -512; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 2688, 896, -5248, 896, 0, 0, 896, -5248, 0, 0, 896, 1920, -512, -512, 0, 5632, -512, 0, 0, 5632, 0, -512; + 2688, 896, 896, -5248, 0, 0, -5248, 896, 0, 0, 896, 1920, -512, -512, 0, -512, 5632, 0, 0, -512, 0, 5632; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 0, 0, 0, 0, -3072, 3072, 0, 0, 3072, -3072, 0, 0, 0, 0, -3072, 0, 0, 3072, 3072, 0, -3072, 0; + 2688, 896, -5248, 896, 0, 0, 896, -5248, 0, 0, 896, 1920, -512, -512, 0, 5632, -512, 0, 0, 5632, 0, -512; + 0, 0, 0, 0, 3072, -3072, 0, 0, -3072, 3072, 0, 0, 0, 0, 3072, 0, 0, -3072, -3072, 0, 3072, 0; + 2688, 896, 896, -5248, 0, 0, -5248, 896, 0, 0, 896, 1920, -512, -512, 0, -512, 5632, 0, 0, -512, 0, 5632] : Matrix (Fin 22) (Fin 22) ℤ) + * (!![-96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 0, -96, 0, 0, 0, 0, 0, 0, 0, 0, 160, -64, -128, -128, 0, 32, 32, 0, 0, 32, 0, 32; + 0, 0, -96, 0, 0, 0, 0, 160, 0, 0, 0, -64, 32, 32, 0, -128, 32, 0, 0, -128, 0, 32; + 0, 0, 0, -96, 0, 0, 160, 0, 0, 0, 0, -64, 32, 32, 0, 32, -128, 0, 0, 32, 0, -128; + 0, 0, 0, 0, -96, 0, 0, 0, -32, 128, 0, 0, 0, 0, 128, 0, 0, -32, -32, 0, 128, 0; + 0, 0, 0, 0, 0, -96, 0, 0, 128, -32, 0, 0, 0, 0, -32, 0, 0, 128, 128, 0, -32, 0; + 0, 0, 0, 160, 0, 0, -96, 0, 0, 0, 0, -64, 32, 32, 0, 32, -128, 0, 0, 32, 0, -128; + 0, 0, 160, 0, 0, 0, 0, -96, 0, 0, 0, -64, 32, 32, 0, -128, 32, 0, 0, -128, 0, 32; + 0, 0, 0, 0, -32, 128, 0, 0, -96, 0, 0, 0, 0, 0, -32, 0, 0, 128, 128, 0, -32, 0; + 0, 0, 0, 0, 128, -32, 0, 0, 0, -96, 0, 0, 0, 0, 128, 0, 0, -32, -32, 0, 128, 0; + 0, 160, 0, 0, 0, 0, 0, 0, 0, 0, -96, -64, -128, -128, 0, 32, 32, 0, 0, 32, 0, 32; + 288, -64, -64, -64, 0, 0, -64, -64, 0, 0, -64, 96, 32, 32, 0, 32, 32, 0, 0, 32, 0, 32; + 96, -128, 32, 32, 0, 0, 32, 32, 0, 0, -128, 32, -64, 128, 0, 0, 0, 0, 0, 0, 0, 0; + 96, -128, 32, 32, 0, 0, 32, 32, 0, 0, -128, 32, 128, -64, 0, 0, 0, 0, 0, 0, 0, 0; + 0, 0, 0, 0, 128, -32, 0, 0, -32, 128, 0, 0, 0, 0, -96, 0, 0, -32, 0, 0, 128, 0; + 96, 32, -128, 32, 0, 0, 32, -128, 0, 0, 32, 32, 0, 0, 0, -64, 0, 0, 0, 128, 0, 0; + 96, 32, 32, -128, 0, 0, -128, 32, 0, 0, 32, 32, 0, 0, 0, 0, -64, 0, 0, 0, 0, 128; + 0, 0, 0, 0, -32, 128, 0, 0, 128, -32, 0, 0, 0, 0, -32, 0, 0, -96, 128, 0, 0, 0; + 0, 0, 0, 0, -32, 128, 0, 0, 128, -32, 0, 0, 0, 0, 0, 0, 0, 128, -96, 0, -32, 0; + 96, 32, -128, 32, 0, 0, 32, -128, 0, 0, 32, 32, 0, 0, 0, 128, 0, 0, 0, -64, 0, 0; + 0, 0, 0, 0, 128, -32, 0, 0, -32, 128, 0, 0, 0, 0, 128, 0, 0, 0, -32, 0, -96, 0; + 96, 32, 32, -128, 0, 0, -128, 32, 0, 0, 32, 32, 0, 0, 0, 0, 128, 0, 0, 0, 0, -64] : Matrix (Fin 22) (Fin 22) ℤ) + = (393216 : ℤ) • contractionProjectorZ := by + ext k l + revert k l + decide +kernel + rw [Q, h1, h2, h3, h4] + +/-- The certificate polynomial expanded into powers. -/ +lemma Q_eq_poly : Q = boostAverageOrbitZ ^ 5 - (92 : ℤ) • boostAverageOrbitZ ^ 4 + + (2816 : ℤ) • boostAverageOrbitZ ^ 3 - (31744 : ℤ) • boostAverageOrbitZ ^ 2 + + (98304 : ℤ) • boostAverageOrbitZ := by + rw [Q] + noncomm_ring + +include hT in +/-- The certificate round: applying the certificate polynomial of the averaged round + to the coefficients reproduces `x` — the combination of five iterated rounds weighted + by the certificate coefficients. -/ +lemma eq_sum_Q_smul {x : B} (c : Fin 22 → ℂ) + (hx : x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k)) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ k, ((9437184 : ℂ)⁻¹ * ∑ l, ((Q k l : ℤ) : ℂ) * c l) + • rotationOrbitSum (T := T) (orbitRep k) := by + have h1 := hT.eq_sum_pow_boostAverageOrbitZ_smul c hx hw 1 + have h2 := hT.eq_sum_pow_boostAverageOrbitZ_smul c hx hw 2 + have h3 := hT.eq_sum_pow_boostAverageOrbitZ_smul c hx hw 3 + have h4 := hT.eq_sum_pow_boostAverageOrbitZ_smul c hx hw 4 + have h5 := hT.eq_sum_pow_boostAverageOrbitZ_smul c hx hw 5 + have key : (27 : ℂ) • x - (207 / 4 : ℂ) • x + (33 : ℂ) • x - (31 / 4 : ℂ) • x + + (2⁻¹ : ℂ) • x + = ∑ k, ((9437184 : ℂ)⁻¹ * ∑ l, ((Q k l : ℤ) : ℂ) * c l) + • rotationOrbitSum (T := T) (orbitRep k) := by + nth_rewrite 1 [h5] + nth_rewrite 1 [h4] + nth_rewrite 1 [h3] + nth_rewrite 1 [h2] + nth_rewrite 1 [h1] + simp only [Finset.smul_sum, smul_smul] + rw [← Finset.sum_sub_distrib, ← Finset.sum_add_distrib, ← Finset.sum_sub_distrib, + ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun k _ => ?_ + simp only [← sub_smul, ← add_smul] + congr 1 + have hQc : ∀ l, ((Q k l : ℤ) : ℂ) + = (((boostAverageOrbitZ ^ 5) k l : ℤ) : ℂ) + - 92 * (((boostAverageOrbitZ ^ 4) k l : ℤ) : ℂ) + + 2816 * (((boostAverageOrbitZ ^ 3) k l : ℤ) : ℂ) + - 31744 * (((boostAverageOrbitZ ^ 2) k l : ℤ) : ℂ) + + 98304 * ((boostAverageOrbitZ k l : ℤ) : ℂ) := fun l => by + rw [Q_eq_poly] + push_cast [Matrix.sub_apply, Matrix.add_apply, Matrix.smul_apply, smul_eq_mul] + ring + have hsplit : ∑ l, ((Q k l : ℤ) : ℂ) * c l + = (∑ l, (((boostAverageOrbitZ ^ 5) k l : ℤ) : ℂ) * c l) + - 92 * (∑ l, (((boostAverageOrbitZ ^ 4) k l : ℤ) : ℂ) * c l) + + 2816 * (∑ l, (((boostAverageOrbitZ ^ 3) k l : ℤ) : ℂ) * c l) + - 31744 * (∑ l, (((boostAverageOrbitZ ^ 2) k l : ℤ) : ℂ) * c l) + + 98304 * (∑ l, ((boostAverageOrbitZ k l : ℤ) : ℂ) * c l) := by + simp only [hQc, Finset.mul_sum, ← Finset.sum_sub_distrib, ← Finset.sum_add_distrib] + exact Finset.sum_congr rfl fun l _ => by ring + rw [hsplit] + field_simp + ring_nf + calc x = (27 : ℂ) • x - (207 / 4 : ℂ) • x + (33 : ℂ) • x - (31 / 4 : ℂ) • x + + (2⁻¹ : ℂ) • x := by module + _ = _ := key + +include hT in +/-- The projector round: the certificate collapses to `24⁻¹` times the integer + projector matrix — one clean application of `contractionProjectorZ` reproduces the + coefficients of any all-axes weight-zero element. -/ +lemma eq_sum_contractionProjectorZ_smul {x : B} (c : Fin 22 → ℂ) + (hx : x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k)) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + x = ∑ k, ((24 : ℂ)⁻¹ * ∑ l, ((contractionProjectorZ k l : ℤ) : ℂ) * c l) + • rotationOrbitSum (T := T) (orbitRep k) := by + rw [hT.eq_sum_Q_smul c hx hw] + refine Finset.sum_congr rfl fun k _ => ?_ + congr 1 + have hP : ∀ l, ((Q k l : ℤ) : ℂ) = 393216 * ((contractionProjectorZ k l : ℤ) : ℂ) := + fun l => by + rw [Q_explicit] + simp only [Matrix.smul_apply, smul_eq_mul] + push_cast + ring + simp only [hP, mul_assoc] + rw [← Finset.mul_sum] + field_simp + ring + +/-! + +## I. The four invariant contractions + +## I.1. The metric and Levi-Civita contractions + +The three double metric contractions — outer `g^{μν} g^{ρσ} T_{μνρσ}`, inner +`g^{μρ} g^{νσ} T_{μνρσ}`, split `g^{μσ} g^{νρ} T_{μνρσ}` — and the Levi-Civita +contraction `ε^{μνρσ} T_{μνρσ}`. + +-/ + +/-- The Minkowski sign of a direction: `+1` on time, `-1` on space. -/ +def minkowskiSignZ : Fin 1 ⊕ Fin 3 → ℤ := Sum.elim (fun _ => 1) (fun _ => -1) + +/-- The Minkowski metric on direction letters. -/ +def etaZ (μ ν : Fin 1 ⊕ Fin 3) : ℤ := if μ = ν then minkowskiSignZ μ else 0 + +/-- The numeric label of a direction, for the Levi-Civita sign. -/ +def dirNum : Fin 1 ⊕ Fin 3 → ℤ := Sum.elim (fun _ => 0) (fun j => (j : ℤ) + 1) + +/-- The Levi-Civita sign of a four-tuple of directions: the product of the signs of the + label differences — `±1` on the permutations of `(t, x, y, z)` and `0` otherwise. -/ +def epsilonSignZ (d : Fin 4 → Fin 1 ⊕ Fin 3) : ℤ := + (dirNum (d 1) - dirNum (d 0)).sign * (dirNum (d 2) - dirNum (d 0)).sign + * (dirNum (d 3) - dirNum (d 0)).sign * (dirNum (d 2) - dirNum (d 1)).sign + * (dirNum (d 3) - dirNum (d 1)).sign * (dirNum (d 3) - dirNum (d 2)).sign + +/-- The outer contraction `g^{μν} g^{ρσ} T_{μνρσ}`. -/ +noncomputable def outerContraction : B := + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 1) * etaZ (d 2) (d 3) : ℤ) : ℂ) • T d + +/-- The inner contraction `g^{μρ} g^{νσ} T_{μνρσ}`. -/ +noncomputable def innerContraction : B := + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 2) * etaZ (d 1) (d 3) : ℤ) : ℂ) • T d + +/-- The split contraction `g^{μσ} g^{νρ} T_{μνρσ}`. -/ +noncomputable def splitContraction : B := + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((etaZ (d 0) (d 3) * etaZ (d 1) (d 2) : ℤ) : ℂ) • T d + +/-- The Levi-Civita contraction `ε^{μνρσ} T_{μνρσ}`. -/ +noncomputable def epsilonContraction : B := + ∑ d : Fin 4 → Fin 1 ⊕ Fin 3, ((epsilonSignZ d : ℤ) : ℂ) • T d + +/-! + +## I.2. Orbit coordinates and the projector factorisation + +Integer orbit vectors and weight rows for each contraction; three times the projector +is the sum of their four rank-one products. + +-/ + +/-- The outer contraction in orbit coordinates (times three). -/ +def outerOrbitZ : Fin 22 → ℤ := ![1, -3, 0, 0, 0, 0, 0, 0, 0, 0, -3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0] + +/-- The inner contraction in orbit coordinates (times three). -/ +def innerOrbitZ : Fin 22 → ℤ := ![1, 0, -3, 0, 0, 0, 0, -3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0] + +/-- The split contraction in orbit coordinates (times three). -/ +def splitOrbitZ : Fin 22 → ℤ := ![1, 0, 0, -3, 0, 0, -3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3] + +/-- The Levi-Civita contraction in orbit coordinates. -/ +def epsilonOrbitZ : Fin 22 → ℤ := ![0, 0, 0, 0, 1, -1, 0, 0, -1, 1, 0, 0, 0, 0, 1, 0, 0, -1, -1, 0, 1, 0] + +/-- The outer weight row of the projector factorisation. -/ +def outerWeightZ : Fin 22 → ℤ := + ![3, -5, 1, 1, 0, 0, 1, 1, 0, 0, -5, 3, 5, 5, 0, -1, -1, 0, 0, -1, 0, -1] + +/-- The inner weight row of the projector factorisation. -/ +def innerWeightZ : Fin 22 → ℤ := + ![3, 1, -5, 1, 0, 0, 1, -5, 0, 0, 1, 3, -1, -1, 0, 5, -1, 0, 0, 5, 0, -1] + +/-- The split weight row of the projector factorisation. -/ +def splitWeightZ : Fin 22 → ℤ := + ![3, 1, 1, -5, 0, 0, -5, 1, 0, 0, 1, 3, -1, -1, 0, -1, 5, 0, 0, -1, 0, 5] + +/-- The Levi-Civita weight row of the projector factorisation. -/ +def epsilonWeightZ : Fin 22 → ℤ := + ![0, 0, 0, 0, 9, -9, 0, 0, -9, 9, 0, 0, 0, 0, 9, 0, 0, -9, -9, 0, 9, 0] + +/-- The projector factors through the four invariants: three times the projector is + the sum of the four rank-one products of an invariant orbit vector with its weight + row. -/ +lemma three_mul_contractionProjectorZ : ∀ k l : Fin 22, + 3 * contractionProjectorZ k l + = outerOrbitZ k * outerWeightZ l + innerOrbitZ k * innerWeightZ l + + splitOrbitZ k * splitWeightZ l + epsilonOrbitZ k * epsilonWeightZ l := by + decide +kernel + +/-! + +## I.3. The orbit vectors represent the contractions + +-/ + +/-- The orbit sum expanded through the orbit multiplicity. -/ +lemma rotationOrbitSum_eq_sum (d : Fin 4 → Fin 1 ⊕ Fin 3) : + rotationOrbitSum (T := T) d + = ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, ((rotationOrbitCoeff d e : ℤ) : ℂ) • T e := by + rw [rotationOrbitSum] + simp [rotationOrbitCoeff, apply_ite (fun n : ℤ => (n : ℂ)), add_smul, ite_smul, + Finset.sum_add_distrib, Finset.sum_ite_eq'] + +/-- A combination of the representative orbit sums, expanded into the generators. -/ +lemma sum_smul_rotationOrbitSum_orbitRep (c : Fin 22 → ℂ) : + ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k) + = ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ k, c k * ((rotationOrbitCoeff (orbitRep k) e : ℤ) : ℂ)) • T e := by + calc ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k) + = ∑ k, ∑ e : Fin 4 → Fin 1 ⊕ Fin 3, + (c k * ((rotationOrbitCoeff (orbitRep k) e : ℤ) : ℂ)) • T e := by + refine Finset.sum_congr rfl fun k _ => ?_ + rw [rotationOrbitSum_eq_sum, Finset.smul_sum] + exact Finset.sum_congr rfl fun e _ => smul_smul _ _ _ + _ = _ := by + rw [Finset.sum_comm] + exact Finset.sum_congr rfl fun e _ => (Finset.sum_smul).symm + +/-- The outer orbit vector against the orbit multiplicities gives the outer metric + coefficients. -/ +lemma sum_outerOrbitZ_mul_rotationOrbitCoeff : ∀ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ k, outerOrbitZ k * rotationOrbitCoeff (orbitRep k) e) + = 3 * (etaZ (e 0) (e 1) * etaZ (e 2) (e 3)) := by + decide +kernel + +/-- The inner orbit vector against the orbit multiplicities gives the inner metric + coefficients. -/ +lemma sum_innerOrbitZ_mul_rotationOrbitCoeff : ∀ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ k, innerOrbitZ k * rotationOrbitCoeff (orbitRep k) e) + = 3 * (etaZ (e 0) (e 2) * etaZ (e 1) (e 3)) := by + decide +kernel + +/-- The split orbit vector against the orbit multiplicities gives the split metric + coefficients. -/ +lemma sum_splitOrbitZ_mul_rotationOrbitCoeff : ∀ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ k, splitOrbitZ k * rotationOrbitCoeff (orbitRep k) e) + = 3 * (etaZ (e 0) (e 3) * etaZ (e 1) (e 2)) := by + decide +kernel + +/-- The Levi-Civita orbit vector against the orbit multiplicities gives the Levi-Civita + signs. -/ +lemma sum_epsilonOrbitZ_mul_rotationOrbitCoeff : ∀ e : Fin 4 → Fin 1 ⊕ Fin 3, + (∑ k, epsilonOrbitZ k * rotationOrbitCoeff (orbitRep k) e) = epsilonSignZ e := by + decide +kernel + +/-- The outer orbit vector represents three times the outer contraction. -/ +lemma sum_outerOrbitZ_smul_rotationOrbitSum : + ∑ k, ((outerOrbitZ k : ℤ) : ℂ) • rotationOrbitSum (T := T) (orbitRep k) + = (3 : ℂ) • outerContraction (T := T) := by + rw [sum_smul_rotationOrbitSum_orbitRep, outerContraction, Finset.smul_sum] + refine Finset.sum_congr rfl fun e _ => ?_ + rw [smul_smul] + congr 1 + exact_mod_cast sum_outerOrbitZ_mul_rotationOrbitCoeff e + +/-- The inner orbit vector represents three times the inner contraction. -/ +lemma sum_innerOrbitZ_smul_rotationOrbitSum : + ∑ k, ((innerOrbitZ k : ℤ) : ℂ) • rotationOrbitSum (T := T) (orbitRep k) + = (3 : ℂ) • innerContraction (T := T) := by + rw [sum_smul_rotationOrbitSum_orbitRep, innerContraction, Finset.smul_sum] + refine Finset.sum_congr rfl fun e _ => ?_ + rw [smul_smul] + congr 1 + exact_mod_cast sum_innerOrbitZ_mul_rotationOrbitCoeff e + +/-- The split orbit vector represents three times the split contraction. -/ +lemma sum_splitOrbitZ_smul_rotationOrbitSum : + ∑ k, ((splitOrbitZ k : ℤ) : ℂ) • rotationOrbitSum (T := T) (orbitRep k) + = (3 : ℂ) • splitContraction (T := T) := by + rw [sum_smul_rotationOrbitSum_orbitRep, splitContraction, Finset.smul_sum] + refine Finset.sum_congr rfl fun e _ => ?_ + rw [smul_smul] + congr 1 + exact_mod_cast sum_splitOrbitZ_mul_rotationOrbitCoeff e + +/-- The Levi-Civita orbit vector represents the Levi-Civita contraction. -/ +lemma sum_epsilonOrbitZ_smul_rotationOrbitSum : + ∑ k, ((epsilonOrbitZ k : ℤ) : ℂ) • rotationOrbitSum (T := T) (orbitRep k) + = epsilonContraction (T := T) := by + rw [sum_smul_rotationOrbitSum_orbitRep, epsilonContraction] + refine Finset.sum_congr rfl fun e _ => ?_ + congr 1 + exact_mod_cast sum_epsilonOrbitZ_mul_rotationOrbitCoeff e + +/-! + +## I.4. The projector round lands in the contractions + +-/ + +include hT in +/-- Boost-invariant orbit combinations are spanned by the four contractions: an + all-axes weight-zero combination of the representative orbit sums is a linear + combination of the outer, inner and split metric contractions and the Levi-Civita + contraction. -/ +theorem exists_smul_contraction_of_eq_sum_orbitRep {x : B} (c : Fin 22 → ℂ) + (hx : x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k)) + (hw : ∀ i : Fin 3, x ∈ boostWeightSubmodule repLorentz i 0) : + ∃ a₁ a₂ a₃ a₄ : ℂ, + x = a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T) + + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) := by + refine ⟨(24 : ℂ)⁻¹ * ∑ l, ((outerWeightZ l : ℤ) : ℂ) * c l, + (24 : ℂ)⁻¹ * ∑ l, ((innerWeightZ l : ℤ) : ℂ) * c l, + (24 : ℂ)⁻¹ * ∑ l, ((splitWeightZ l : ℤ) : ℂ) * c l, + (72 : ℂ)⁻¹ * ∑ l, ((epsilonWeightZ l : ℤ) : ℂ) * c l, ?_⟩ + rw [hT.eq_sum_contractionProjectorZ_smul c hx hw] + have hfac : ∀ k, (24 : ℂ)⁻¹ * ∑ l, ((contractionProjectorZ k l : ℤ) : ℂ) * c l + = ((outerOrbitZ k : ℤ) : ℂ) * ((72 : ℂ)⁻¹ * ∑ l, ((outerWeightZ l : ℤ) : ℂ) * c l) + + ((innerOrbitZ k : ℤ) : ℂ) * ((72 : ℂ)⁻¹ * ∑ l, ((innerWeightZ l : ℤ) : ℂ) * c l) + + ((splitOrbitZ k : ℤ) : ℂ) * ((72 : ℂ)⁻¹ * ∑ l, ((splitWeightZ l : ℤ) : ℂ) * c l) + + ((epsilonOrbitZ k : ℤ) : ℂ) + * ((72 : ℂ)⁻¹ * ∑ l, ((epsilonWeightZ l : ℤ) : ℂ) * c l) := by + intro k + have hZ : ∀ l, ((contractionProjectorZ k l : ℤ) : ℂ) + = (3 : ℂ)⁻¹ * (((outerOrbitZ k : ℤ) : ℂ) * ((outerWeightZ l : ℤ) : ℂ) + + ((innerOrbitZ k : ℤ) : ℂ) * ((innerWeightZ l : ℤ) : ℂ) + + ((splitOrbitZ k : ℤ) : ℂ) * ((splitWeightZ l : ℤ) : ℂ) + + ((epsilonOrbitZ k : ℤ) : ℂ) * ((epsilonWeightZ l : ℤ) : ℂ)) := by + intro l + have h := three_mul_contractionProjectorZ k l + have h' := congrArg (fun n : ℤ => ((n : ℤ) : ℂ)) h + push_cast at h' + field_simp + linear_combination h' + simp only [Finset.mul_sum, ← Finset.sum_add_distrib] + refine Finset.sum_congr rfl fun l _ => ?_ + rw [hZ l] + field_simp + ring + simp only [hfac, add_smul, Finset.sum_add_distrib] + have hpull : ∀ (v : Fin 22 → ℤ) (α : ℂ), + (∑ k, (((v k : ℤ) : ℂ) * α) • rotationOrbitSum (T := T) (orbitRep k)) + = α • ∑ k, ((v k : ℤ) : ℂ) • rotationOrbitSum (T := T) (orbitRep k) := by + intro v α + rw [Finset.smul_sum] + refine Finset.sum_congr rfl fun k _ => ?_ + rw [smul_smul, mul_comm] + rw [hpull outerOrbitZ _, hpull innerOrbitZ _, hpull splitOrbitZ _, hpull epsilonOrbitZ _, + sum_outerOrbitZ_smul_rotationOrbitSum, sum_innerOrbitZ_smul_rotationOrbitSum, + sum_splitOrbitZ_smul_rotationOrbitSum, sum_epsilonOrbitZ_smul_rotationOrbitSum] + refine congrArg₂ (· + ·) (congrArg₂ (· + ·) (congrArg₂ (· + ·) ?_ ?_) ?_) ?_ + · rw [smul_smul] + congr 1 + field_simp + ring + · rw [smul_smul] + congr 1 + field_simp + ring + · rw [smul_smul] + congr 1 + field_simp + ring + · rfl +/-! + +## J. The classification of the Lorentz invariants + +## J.1. Graded extraction along the sieve + +An invariant element has weight zero along every axis, so it passes down the sieve of +sections D and E: each covering step keeps only its weight-zero member. + +-/ + +/-- Finite decomposition of an `iSup` membership: an element of the join of a + `ℤ`-indexed family is a finitely supported sum of members. -/ +lemma exists_finsupp_of_mem_iSup {S : ℤ → Submodule ℂ B} {x : B} (hx : x ∈ ⨆ m, S m) : + ∃ f : ℤ →₀ B, (∀ m, f m ∈ S m) ∧ x = f.sum fun _ b => b := by + refine Submodule.iSup_induction + (motive := fun y => ∃ f : ℤ →₀ B, (∀ m, f m ∈ S m) ∧ y = f.sum fun _ b => b) + S hx ?_ ?_ ?_ + · intro m y hy + refine ⟨Finsupp.single m y, fun m' => ?_, by simp [Finsupp.sum_single_index]⟩ + rcases eq_or_ne m' m with rfl | hne + · rw [Finsupp.single_eq_same] + exact hy + · rw [Finsupp.single_eq_of_ne hne] + exact Submodule.zero_mem _ + · exact ⟨0, fun m => Submodule.zero_mem _, by simp⟩ + · rintro y z ⟨f, hf, rfl⟩ ⟨g, hg, rfl⟩ + refine ⟨f + g, fun m => by rw [Finsupp.add_apply]; exact add_mem (hf m) (hg m), ?_⟩ + rw [Finsupp.sum_add_index (fun m _ => rfl) (fun m _ b₁ b₂ => rfl)] + +/-- Graded extraction: an element of the join of a family bounded by the boost-weight + grading which itself has weight zero lies in the zero member of the family. -/ +lemma mem_of_mem_iSup_of_boostWeight_zero {i : Fin 3} {S : ℤ → Submodule ℂ B} + (hS : ∀ m : ℤ, S m ≤ boostWeightSubmodule repLorentz i m) {x : B} + (hx : x ∈ ⨆ m, S m) (h0 : x ∈ boostWeightSubmodule repLorentz i 0) : x ∈ S 0 := by + obtain ⟨f, hf, rfl⟩ := exists_finsupp_of_mem_iSup hx + have hkey := eq_component_zero_of_mem_boostWeightSubmodule (i := i) + (s := insert 0 f.support) (w := fun m => f m) h0 + (fun m _ => hS m (hf m)) (Finset.mem_insert_self 0 _) ?_ + · rw [hkey] + exact hf 0 + · rw [Finsupp.sum] + by_cases h : (0 : ℤ) ∈ f.support + · rw [Finset.insert_eq_self.2 h] + · rw [Finset.sum_insert h, Finsupp.notMem_support_iff.1 h, zero_add] + +/-- Invariance gives boost weight zero: an element fixed by the Lorentz group lies in + the weight-zero space of every boost axis. -/ +lemma mem_boostWeightSubmodule_zero_of_invariant {x : B} + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) (i : Fin 3) : + x ∈ boostWeightSubmodule repLorentz i 0 := by + rw [mem_boostWeightSubmodule] + intro t ht + rw [hinv, zpow_zero, one_smul] + +/-! + +## J.2. The classification + +-/ + +include hT in +/-- Every Lorentz-invariant element is an orbit-sum combination: an element of the + span of the components fixed by the Lorentz group is a combination of the orbit sums + of the `22` canonical representatives. -/ +theorem exists_eq_sum_orbitRep_of_invariant {x : B} (hx : x ∈ hT.span) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ c : Fin 22 → ℂ, x = ∑ k, c k • rotationOrbitSum (T := T) (orbitRep k) := by + have hw := mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv + have h1 : x ∈ hT.boostPiece 0 0 := by + refine mem_of_mem_iSup_of_boostWeight_zero (i := 0) + (hT.boostPiece_le_boostWeightSubmodule 0) ?_ (hw 0) + rw [← hT.span_eq_iSup_boostPiece 0] + exact hx + have h2 : x ∈ hT.boostPiece₂ 0 1 0 0 := + mem_of_mem_iSup_of_boostWeight_zero (i := 1) + (hT.boostPiece₂_le_boostWeightSubmodule 0 1 0) + (hT.boostPiece_le_iSup_boostPiece₂ 0 1 0 h1) (hw 1) + have h3 : x ∈ hT.boostPiece₃ 0 := + mem_of_mem_iSup_of_boostWeight_zero (i := 2) + hT.boostPiece₃_le_boostWeightSubmodule + (hT.boostPiece₂_le_iSup_boostPiece₃ h2) (hw 2) + have h4 : x ∈ pairedOrDistinctSubmodule (T := T) := + hT.boostPiece₃_zero_le_iSup_pairedOrDistinct h3 + have havg : rotationAverage (repLorentz := repLorentz) x = x := by + rw [rotationAverage] + simp only [LinearMap.smul_apply, LinearMap.add_apply, LinearMap.id_apply] + rw [hinv rotationCycle, hinv (rotationCycle ^ 2)] + module + have h5 : x ∈ rotationSubmodule (repLorentz := repLorentz) (T := T) := + havg ▸ Submodule.mem_map_of_mem h4 + obtain ⟨c, hc⟩ := hT.exists_eq_sum_rotationSubset_of_mem_rotationSubmodule h5 + refine ⟨fun k => c (orbitRep k), ?_⟩ + rw [hc, sum_rotationSubset (fun d => c d • rotationOrbitSum (T := T) d)] + +include hT in +/-- The classification of the Lorentz invariants: every element of the span of the + components fixed by the Lorentz group is a linear combination of the outer, inner and + split metric contractions and the Levi-Civita contraction. -/ +theorem exists_smul_contraction_of_invariant {x : B} (hx : x ∈ hT.span) + (hinv : ∀ g : SL(2,ℂ), repLorentz g x = x) : + ∃ a₁ a₂ a₃ a₄ : ℂ, + x = a₁ • outerContraction (T := T) + a₂ • innerContraction (T := T) + + a₃ • splitContraction (T := T) + a₄ • epsilonContraction (T := T) := by + obtain ⟨c, hc⟩ := hT.exists_eq_sum_orbitRep_of_invariant hx hinv + exact hT.exists_smul_contraction_of_eq_sum_orbitRep c hc + (mem_boostWeightSubmodule_zero_of_invariant (repLorentz := repLorentz) hinv) + + + +end IsQuadLorentz + +end Lorentz diff --git a/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean b/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean index 41748ad77..f16ddd3b9 100644 --- a/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean +++ b/Physlib/Relativity/PauliMatrices/SelfAdjoint.lean @@ -7,6 +7,7 @@ module public import Physlib.Relativity.PauliMatrices.Basic public import Physlib.Relativity.MinkowskiMatrix +public import Physlib.Mathematics.KroneckerDelta.Basic /-! ## Interaction of Pauli matrices with self-adjoint matrices @@ -15,7 +16,7 @@ public import Physlib.Relativity.MinkowskiMatrix @[expose] public section namespace PauliMatrix -open Matrix Module +open Matrix Module KroneckerDelta /-- The trace of a pauli-matrix multiplied by a self-adjoint `2×2` matrix is real. -/ lemma trace_pauliMatrix_mul_selfAdjoint_re (μ : Fin 1 ⊕ Fin 3) @@ -96,6 +97,12 @@ lemma pauliSelfAdjoint_linearly_independent : LinearIndependent ℝ pauliSelfAdj trace_add, trace_smul, ZeroMemClass.coe_zero, mul_zero, trace_zero] at h1 fin_cases i <;> simpa [pauliMatrix] using h1 +/-- Pauli matrices are orthogonal with respect to the trace pairing: `tr(σ_μ σ_ν) = 2 δ_μν`. -/ +@[simp] +lemma trace_pauliMatrix_mul_pauliMatrix (μ ν : Fin 1 ⊕ Fin 3) : + Matrix.trace (pauliMatrix μ * pauliMatrix ν) = ((2 * kroneckerDelta μ ν : ℕ) : ℂ) := by + fin_cases μ <;> fin_cases ν <;> simp [kroneckerDelta, pauliMatrix] <;> norm_num + /-- The Pauli matrices span all self-adjoint matrices. -/ lemma pauliSelfAdjoint_span : ⊤ ≤ Submodule.span ℝ (Set.range pauliSelfAdjoint) := by refine (Submodule.top_le_span_range_iff_forall_exists_fun ℝ).mpr ?_ @@ -148,6 +155,33 @@ def pauliSelfAdjoint' (i : Fin 1 ⊕ Fin 3) : selfAdjoint (Matrix (Fin 2) (Fin 2 | Sum.inr 1 => ⟨-σ2, by rw [AddSubgroup.neg_mem_iff]; exact pauliMatrix_selfAdjoint _⟩ | Sum.inr 2 => ⟨-σ3, by rw [AddSubgroup.neg_mem_iff]; exact pauliMatrix_selfAdjoint _⟩ +/-- Trace orthogonality of the covariant Pauli basis: + `tr (σ'_a σ'_b) = 2 δ_{a b}`. -/ +lemma trace_pauliSelfAdjoint'_mul (a b : Fin 1 ⊕ Fin 3) : + Matrix.trace ((pauliSelfAdjoint' a).1 * (pauliSelfAdjoint' b).1) = + if a = b then 2 else 0 := by + rcases a with a | a <;> rcases b with b | b <;> + fin_cases a <;> fin_cases b <;> + simp only [pauliSelfAdjoint', Matrix.neg_mul, Matrix.mul_neg, + Matrix.trace_neg, neg_neg, trace_pauliMatrix_mul_pauliMatrix, + KroneckerDelta.kroneckerDelta] <;> + simp + +/-- The trace pairing of a covariant Pauli matrix with an arbitrary matrix, expressed through the +matrix entries. -/ +lemma trace_pauliSelfAdjoint'_mul_apply (l : Fin 1 ⊕ Fin 3) + (N : Matrix (Fin 2) (Fin 2) ℂ) : + Matrix.trace ((pauliSelfAdjoint' l).1 * N) = + match l with + | Sum.inl 0 => N 0 0 + N 1 1 + | Sum.inr 0 => -(N 0 1 + N 1 0) + | Sum.inr 1 => -(Complex.I * (N 0 1 - N 1 0)) + | Sum.inr 2 => -(N 0 0 - N 1 1) := by + rcases l with l | l <;> fin_cases l <;> + simp [pauliSelfAdjoint', pauliMatrix, Matrix.trace, Matrix.mul_apply, + Fin.sum_univ_two, Matrix.diag] <;> + ring + /-- The Pauli matrices where `σi` are negated are linearly independent. -/ lemma pauliSelfAdjoint'_linearly_independent : LinearIndependent ℝ pauliSelfAdjoint' := by apply Fintype.linearIndependent_iff.mpr diff --git a/Physlib/Relativity/SL2C/AxisRotations.lean b/Physlib/Relativity/SL2C/AxisRotations.lean new file mode 100644 index 000000000..a4b8022ff --- /dev/null +++ b/Physlib/Relativity/SL2C/AxisRotations.lean @@ -0,0 +1,127 @@ +/- +Copyright (c) 2026 Joseph Tooby-Smith. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Jinzheng Li, Nathaneal Sajan, Joseph Tooby-Smith +-/ +module + +public import Physlib.Relativity.SL2C.Basic +/-! +# Coordinate-axis rotations in `SL(2,ℂ)` + +This file defines chosen `SL(2,ℂ)` rotations carrying the `z`-axis to a selected coordinate axis. +The spatial-axis convention is `0 = x`, `1 = y`, and `2 = z`; consequently, the rotation associated +with axis `2` is the identity. + +Conjugation by these rotations transports a matrix written in the diagonal `z`-axis basis to +the corresponding coordinate-axis basis. This provides the common change of basis used by +coordinate-axis boosts and later constructions based on diagonal representatives. + +The main declarations are: + +- `rotationZToAxis`, the indexed family of rotations; +- `rotationZToAxis_zero_apply` and its companions, their matrix entries; +- `rotationZToAxis_zero_mul_diagonal_mul_inv` and its companions, their action on a + diagonal matrix. +-/ + +@[expose] public section + +namespace Lorentz.SL2C + +open Matrix MatrixGroups + +/-- The `SL(2,ℂ)` rotation carrying the `z`-axis to axis `i`. -/ +noncomputable def rotationZToAxis : Fin 3 → SL(2,ℂ) + | 0 => + ⟨(((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, -1; 1, 1], by + rw [Matrix.det_smul, Matrix.det_fin_two_of, Fintype.card_fin, inv_pow] + norm_num [← Complex.ofReal_pow, Real.sq_sqrt]⟩ + | 1 => + ⟨(((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, Complex.I; Complex.I, 1], by + rw [Matrix.det_smul, Matrix.det_fin_two_of, Fintype.card_fin, inv_pow, + Complex.I_mul_I] + norm_num [← Complex.ofReal_pow, Real.sq_sqrt]⟩ + | 2 => 1 + +/-- The matrix entries of the rotation carrying the `z`-axis to the `x`-axis. -/ +@[simp] lemma rotationZToAxis_zero_apply (j k : Fin 2) : + (rotationZToAxis 0).1 j k = + ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, -1; 1, 1]) j k := rfl + +/-- The matrix entries of the rotation carrying the `z`-axis to the `y`-axis. -/ +@[simp] lemma rotationZToAxis_one_apply (j k : Fin 2) : + (rotationZToAxis 1).1 j k = + ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, Complex.I; Complex.I, 1]) j k := rfl + +/-- The rotation carrying the `z`-axis to itself is the identity matrix. -/ +@[simp] lemma rotationZToAxis_two_apply (j k : Fin 2) : + (rotationZToAxis 2).1 j k = (1 : Matrix (Fin 2) (Fin 2) ℂ) j k := rfl + +/-- The matrix entries of the inverse rotation from the `x`-axis to the `z`-axis. -/ +@[simp] lemma rotationZToAxis_zero_inv_apply (j k : Fin 2) : + ((rotationZToAxis 0)⁻¹).1 j k = + ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, 1; -1, 1]) j k := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> simp [rotationZToAxis] + +/-- The matrix entries of the inverse rotation from the `y`-axis to the `z`-axis. -/ +@[simp] lemma rotationZToAxis_one_inv_apply (j k : Fin 2) : + ((rotationZToAxis 1)⁻¹).1 j k = + ((((Real.sqrt 2 : ℝ) : ℂ))⁻¹ • !![1, -Complex.I; -Complex.I, 1]) j k := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> simp [rotationZToAxis] + +/-- The inverse rotation from the `z`-axis to itself is the identity matrix. -/ +@[simp] lemma rotationZToAxis_two_inv_apply (j k : Fin 2) : + ((rotationZToAxis 2)⁻¹).1 j k = (1 : Matrix (Fin 2) (Fin 2) ℂ) j k := by + rw [Matrix.SpecialLinearGroup.SL2_inv_expl] + fin_cases j <;> fin_cases k <;> simp [rotationZToAxis] + +/-- Conjugating `diag(a, b)` by the rotation to the `x`-axis expresses it in the `x`-axis +basis. -/ +lemma rotationZToAxis_zero_mul_diagonal_mul_inv (a b : ℂ) : + (rotationZToAxis 0).1 * !![a, 0; 0, b] * ((rotationZToAxis 0)⁻¹).1 = + !![(a + b) / 2, (a - b) / 2; (a - b) / 2, (a + b) / 2] := by + have hsqrt_ne : (((Real.sqrt 2 : ℝ) : ℂ)) ≠ 0 := by simp + ext j k + fin_cases j <;> fin_cases k <;> + simp only [Matrix.mul_apply, Fin.sum_univ_two, rotationZToAxis_zero_apply, + rotationZToAxis_zero_inv_apply] <;> + simp <;> + field_simp <;> + norm_num [← Complex.ofReal_pow, Real.sq_sqrt] <;> + ring + +/-- Conjugating `diag(a, b)` by the rotation to the `y`-axis expresses it in the `y`-axis +basis. -/ +lemma rotationZToAxis_one_mul_diagonal_mul_inv (a b : ℂ) : + (rotationZToAxis 1).1 * !![a, 0; 0, b] * ((rotationZToAxis 1)⁻¹).1 = + !![(a + b) / 2, -Complex.I * (a - b) / 2; + Complex.I * (a - b) / 2, (a + b) / 2] := by + have hsqrt_ne : (((Real.sqrt 2 : ℝ) : ℂ)) ≠ 0 := by simp + ext j k + fin_cases j <;> fin_cases k + all_goals + simp only [Matrix.mul_apply, Fin.sum_univ_two, rotationZToAxis_one_apply, + rotationZToAxis_one_inv_apply] + simp only [Fin.zero_eta, Fin.isValue, Matrix.smul_apply, of_apply, cons_val', + cons_val_zero, cons_val_fin_one, smul_eq_mul, mul_one, cons_val_one, mul_zero, + add_zero, zero_add, mul_neg, neg_mul, Fin.mk_one] + field_simp + norm_num [← Complex.ofReal_pow, Real.sq_sqrt] + all_goals ring + +/-- Conjugating `diag(a, b)` by the identity rotation leaves it unchanged. -/ +lemma rotationZToAxis_two_mul_diagonal_mul_inv (a b : ℂ) : + (rotationZToAxis 2).1 * !![a, 0; 0, b] * ((rotationZToAxis 2)⁻¹).1 = + !![a, 0; 0, b] := by + ext j k + fin_cases j <;> fin_cases k <;> + simp only [Matrix.mul_apply, Fin.sum_univ_two, rotationZToAxis_two_apply, + rotationZToAxis_two_inv_apply] <;> + simp [Matrix.one_apply] + +end Lorentz.SL2C + +end diff --git a/Physlib/Relativity/SL2C/Basic.lean b/Physlib/Relativity/SL2C/Basic.lean index 3f7ba29f2..d379397f3 100644 --- a/Physlib/Relativity/SL2C/Basic.lean +++ b/Physlib/Relativity/SL2C/Basic.lean @@ -203,6 +203,38 @@ lemma toSelfAdjointMap_pauliBasis (i : Fin 1 ⊕ Fin 3) : apply congrArg exact Eq.symm (minkowskiMatrix.dual_apply_minkowskiMatrix ((toLorentzGroup M).1) i j) +/-- The matrix elements of the covering map through the trace pairing: + `L(M)_{l i} = ½ tr (σ'_l · M σ'_i M†)`. -/ +lemma toLorentzGroup_eq_trace (M : SL(2,ℂ)) (l i : Fin 1 ⊕ Fin 3) : + (((toLorentzGroup M).1 l i : ℝ) : ℂ) = + Matrix.trace ((PauliMatrix.pauliSelfAdjoint' l).1 * + (M.1 * (PauliMatrix.pauliSelfAdjoint' i).1 * M.1ᴴ)) / 2 := by + have h := congrArg (fun A : selfAdjoint (Matrix (Fin 2) (Fin 2) ℂ) => + Matrix.trace ((PauliMatrix.pauliSelfAdjoint' l).1 * A.1)) + (toSelfAdjointMap_basis (M := M) i) + simp only [toSelfAdjointMap_apply_coe, PauliMatrix.pauliBasis', + Module.Basis.coe_mk, AddSubmonoidClass.coe_finsetSum, selfAdjoint.val_smul, + Matrix.mul_sum, Matrix.trace_sum, Matrix.mul_smul, Matrix.trace_smul, + PauliMatrix.trace_pauliSelfAdjoint'_mul, smul_ite, smul_zero, Finset.sum_ite_eq, + Finset.mem_univ, if_true] at h + rw [h, real_smul] + ring + +/-- The covering map intertwines conjugate transposition with matrix + transposition: `L(M†) = L(M)ᵀ`. -/ +lemma toLorentzGroup_conjTranspose {M N : SL(2,ℂ)} (hN : N.1 = M.1ᴴ) : + (toLorentzGroup N).1 = (toLorentzGroup M).1ᵀ := by + ext l i + refine Complex.ofReal_injective ?_ + have h1 := toLorentzGroup_eq_trace N l i + have h2 := toLorentzGroup_eq_trace M i l + rw [hN] at h1 + rw [Matrix.transpose_apply, h1, h2] + congr 1 + rw [Matrix.conjTranspose_conjTranspose, ← Matrix.mul_assoc, ← Matrix.mul_assoc, + Matrix.trace_mul_cycle, ← Matrix.mul_assoc, Matrix.trace_mul_comm, + ← Matrix.mul_assoc] + /-- The first column of the Lorentz matrix formed from an element of `SL(2, ℂ)`. -/ lemma toLorentzGroup_fst_col (M : SL(2, ℂ)) : (fun μ => (toLorentzGroup M).1 μ (Sum.inl 0)) = fun μ => diff --git a/scripts/MetaPrograms/spellingWords.txt b/scripts/MetaPrograms/spellingWords.txt index 3500be8da..5160fc5b4 100644 --- a/scripts/MetaPrograms/spellingWords.txt +++ b/scripts/MetaPrograms/spellingWords.txt @@ -620,6 +620,9 @@ coupling couplings covariance covariant +covariantization +covariantized +covariantizing covector covectors cover diff --git a/scripts/style-exceptions.txt b/scripts/style-exceptions.txt index e69de29bb..80c49ab83 100644 --- a/scripts/style-exceptions.txt +++ b/scripts/style-exceptions.txt @@ -0,0 +1 @@ +Physlib/Particles/QED/Basic.lean : line 1 : ERR_NUM_LIN : 1700 file contains 1519 lines, try to split it up diff --git a/scripts/todos.py b/scripts/todos.py new file mode 100644 index 000000000..b557f9aaf --- /dev/null +++ b/scripts/todos.py @@ -0,0 +1,266 @@ +#!/usr/bin/env python3 +""" +todos.py -- list the TODOs this branch introduces, relative to its merge-base. + +Scans the working tree and the merge-base with the same matcher and subtracts +the sets, so the output is "what this PR adds", not "every TODO in Physlib". +The default scans the working tree, so uncommitted edits are visible and the +file can be regenerated in the same commit that changes a TODO. + +Pass --head to read another ref instead, straight out of the object store: no +checkout, no branch switching, working tree untouched. + + python scripts/todos.py # to the terminal + python scripts/todos.py --md todos.md + python scripts/todos.py --head joseph/AddPotentialAlgebra +""" + +import argparse +import os +import re +import subprocess +import sys +import textwrap + +DEFAULT_MASTER = "upstream/master" +DEFAULT_ROOT = "Physlib" + +# Physlib/Meta/TODO/ implements the TODO command; it is *about* todos and would +# otherwise dominate the output. scripts/ likewise. QuantumInfo/ is a separate +# subproject with its own `--TODO` convention and is out of scope. +EXCLUDE = re.compile(r"(^|/)(Meta|scripts)/") + +CMD_START = re.compile(r'^\s*TODO\s+"') # TODO "..." (Lean command) +DOC_LINE = re.compile(r"^\s*/-!\s*TODO:\s*") # /-! TODO: ... -/ +LOOSE = re.compile(r"todo", re.I) + +# Matches `todo` but is not a work item: section headings, and identifiers that +# merely contain the word. +NOISE = re.compile( + r"(^\s*#{1,6}\s*TODO\b)" # '## TODO' section heading + r"|(Physlib\.Meta\.TODO)" + r"|(TODO_to_yml|FullTODO|todoExtension|todoInfo|allTODO)" + # Prose *about* todos, mostly in module docstrings, not work items. + r"|(collecting TODO items)|(contains only TODO items)" + r"|(is a TODO to)|(Open TODO items)|(see the `TODO`)", + re.I, +) + + +def git(repo, *args): + out = subprocess.run(["git", "-C", repo, *args], capture_output=True, check=True) + return out.stdout.decode("utf-8", "replace") + + +def list_files(repo, ref, root): + paths = git(repo, "ls-tree", "-r", "--name-only", ref, "--", root).splitlines() + return [p for p in paths if p.endswith(".lean") and not EXCLUDE.search(p)] + + +def read_blobs(repo, ref, paths): + """Bulk-read many blobs in one subprocess. Returns {path: text}.""" + proc = subprocess.Popen( + ["git", "-C", repo, "cat-file", "--batch"], + stdin=subprocess.PIPE, stdout=subprocess.PIPE, + ) + out, _ = proc.communicate("".join(f"{ref}:{p}\n" for p in paths).encode()) + + blobs, pos = {}, 0 + for path in paths: + nl = out.find(b"\n", pos) + if nl == -1: + break + header = out[pos:nl].decode("utf-8", "replace") + pos = nl + 1 + if header.endswith(("missing", "ambiguous")): + continue + size = int(header.rsplit(" ", 1)[1]) + blobs[path] = out[pos:pos + size].decode("utf-8", "replace") + pos += size + 1 # trailing newline after the blob + return blobs + + +def parse_file(path, text): + """Yield (path, line, kind, content) items, coalescing wrapped ones.""" + lines = text.splitlines() + items, unclassified = [], [] + i = 0 + while i < len(lines): + line = lines[i] + + # --- TODO "..." command; the string may span several lines ----------- + if CMD_START.match(line): + start = i + body = line[line.index('"') + 1:] + while '"' not in body.replace('\\"', ""): + i += 1 + if i >= len(lines): + break + body += " " + lines[i].strip() + if '"' in body: + body = body[:body.rindex('"')] + items.append((path, start + 1, "cmd", " ".join(body.split()))) + i += 1 + continue + + # --- /-! TODO: ... -/ runs; capitalised first word starts a new item -- + if DOC_LINE.match(line): + start = i + body = DOC_LINE.sub("", line).replace("-/", "").strip() + while i + 1 < len(lines) and DOC_LINE.match(lines[i + 1]): + nxt = DOC_LINE.sub("", lines[i + 1]).replace("-/", "").strip() + first = nxt.split(" ", 1)[0] if nxt else "" + if first[:1].isupper(): # heuristic: new sentence, new item + break + body += " " + nxt + i += 1 + items.append((path, start + 1, "doc", " ".join(body.split()))) + i += 1 + continue + + if LOOSE.search(line) and not NOISE.search(line): + unclassified.append((path, i + 1, "?", line.strip())) + i += 1 + + return items, unclassified + + +def list_files_worktree(repo, root): + paths = git(repo, "ls-files", "--", root).splitlines() + return [p for p in paths if p.endswith(".lean") and not EXCLUDE.search(p)] + + +def read_worktree(repo, paths): + blobs = {} + for path in paths: + try: + with open(os.path.join(repo, path), encoding="utf-8") as fh: + blobs[path] = fh.read() + except OSError: + continue + return blobs + + +def scan(repo, ref, root): + """ref=None scans the working tree, so uncommitted edits are visible.""" + if ref is None: + paths = list_files_worktree(repo, root) + blobs = read_worktree(repo, paths) + else: + paths = list_files(repo, ref, root) + blobs = read_blobs(repo, ref, paths) + + items, unknown = [], [] + for path, text in blobs.items(): + a, b = parse_file(path, text) + items += a + unknown += b + return items, unknown, len(paths) + + +def key(content): + """Identity of a TODO: its text, path-independent so moves aren't churn.""" + return " ".join(content.lower().split()).rstrip(".") + + +def group_by_dir(items): + by_dir = {} + for path, line, _, content in sorted(items): + by_dir.setdefault(path.rsplit("/", 1)[0], []).append((path, line, content)) + return by_dir + + +def emit_terminal(items, unknown, meta, plain): + print("# TODOs introduced by this branch") + print(f"# base {meta['base'][:8]} -> head {meta['head'][:8]} ({meta['date']})") + print(f"# {meta['files']} files - {len(items)} new\n") + + for directory, group in sorted(group_by_dir(items).items()): + if plain: + for path, _, content in group: + print(f"{path} | {content}") + continue + print(directory.replace("Physlib/", "")) + for path, line, content in group: + name = path.rsplit("/", 1)[1] + head, *rest = textwrap.wrap(content, 62) or [""] + label = f"{name}:{line}" + print(f" {label:<34} {head}") + for cont in rest: + print(f" {'':<34} {cont}") + print() + + if unknown: + print(f"UNCLASSIFIED ({len(unknown)}) - matched /todo/i, no known form:") + for path, line, _, content in sorted(unknown): + print(f" {path}:{line} {content[:70]}") + + +def md_escape(text): + """Brackets would terminate the link text early.""" + return text.replace("[", "\\[").replace("]", "\\]") + + +def emit_md(items, meta, repo_url, link_ref): + out = [ + "# TODOs introduced by this branch", + "", + f"{len(items)} open · as of {meta['date']}", + "", + "> Regenerate with `python scripts/todos.py --md todos.md` after adding or", + "> resolving a TODO, and commit it in the same commit.", + "", + '**Format.** Use the `TODO "…"` command', + "", + ] + for directory, group in sorted(group_by_dir(items).items()): + out += [f"### `{directory.replace('Physlib/', '')}`", ""] + for path, line, content in group: + name = path.rsplit("/", 1)[1] + link = f"{repo_url}/blob/{link_ref}/{path}#L{line}" + out.append(f"- {md_escape(content)}  [`{name}:{line}`]({link})") + out.append("") + + return "\n".join(out) + + +def main(): + # Lean sources are full of ℂ, ℝ, ψ; the Windows console defaults to cp1252. + sys.stdout.reconfigure(encoding="utf-8", errors="replace") + + ap = argparse.ArgumentParser() + ap.add_argument("--repo", default=".") + ap.add_argument("--head", default=None, help="defaults to the working tree") + ap.add_argument("--base", default=None, help="defaults to merge-base with master") + ap.add_argument("--master", default=DEFAULT_MASTER) + ap.add_argument("--root", default=DEFAULT_ROOT) + ap.add_argument("--plain", action="store_true", help="no line numbers; diff-friendly") + ap.add_argument("--md") + ap.add_argument("--repo-url", default="https://github.com/jstoobysmith/JTSphyslib") + # Link against the branch, not the head SHA: a SHA in every URL would rewrite + # every line of todos.md on each push, even when no TODO changed. + ap.add_argument("--link-ref", default="AddPotentialAlgebra") + args = ap.parse_args() + + head_sha = git(args.repo, "rev-parse", args.head or "HEAD").strip() + date = git(args.repo, "log", "-1", "--format=%ad", "--date=short", + args.head or "HEAD").strip() + base = args.base or git(args.repo, "merge-base", args.master, + args.head or "HEAD").strip() + + items, unknown, nfiles = scan(args.repo, args.head, args.root) + base_items, _, _ = scan(args.repo, base, args.root) + + base_keys = {key(c) for *_, c in base_items} + items = [it for it in items if key(it[3]) not in base_keys] + + meta = {"base": base, "head": head_sha, "date": date, "files": nfiles} + + emit_terminal(items, unknown, meta, args.plain) + if args.md: + with open(args.md, "w", encoding="utf-8") as fh: + fh.write(emit_md(items, meta, args.repo_url, args.link_ref)) + + +if __name__ == "__main__": + main() diff --git a/todos.md b/todos.md new file mode 100644 index 000000000..0e3dcf1f8 --- /dev/null +++ b/todos.md @@ -0,0 +1,58 @@ +# TODOs introduced by this branch + +20 open · as of 2026-08-25 + +> Regenerate with `python scripts/todos.py --md todos.md` after adding or +> resolving a TODO, and commit it in the same commit. + +**Format.** Use the `TODO "…"` command + +### `Particles/PureFermionic` + +- Move the diagonal `SL(2, ℂ)` material `diagSL`, `diagSL_inv`, `diagSL_neg_one` and `twoI` to `Physlib.Relativity.SL2C.Basic`, their canonical home, when the effective-potential development is split up.  [`EFTLagrangianExclDeriv.lean:162`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/PureFermionic/EFTLagrangianExclDeriv.lean#L162) + +### `Particles/QED` + +- Prove the composition law of the Lorentz action. Being a pullback on coordinates it is a right action, `lorentzAction M ∘ lorentzAction N = lorentzAction (N * M)`; the proof needs permutation-invariance and functoriality of `derivSum` over sorted lists.  [`Basic.lean:1431`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Basic.lean#L1431) +- Define an antilinear star on the QED jet algebra with `star ψ = ψ̄`, `star A = A`, and prove hermiticity of the Lagrangian up to the total derivative of the kinetic term.  [`Basic.lean:1434`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Basic.lean#L1434) +- Connect the QED matter content to `Physlib.QFT.QED.AnomalyCancellation`: the electron spectrum is vector-like (charges `±1`), so it satisfies the gravitational and cubic anomaly cancellation conditions.  [`CurrentCoupling.lean:56`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/CurrentCoupling.lean#L56) +- Classify the gauge- and Lorentz-invariant elements of mass dimension at most four of the full QED jet algebra: the analogue for the Dirac electron of the classification `LeptonGaugeSector.JetAlgebra.MassDimFour.Classification`, showing the QED Lagrangian is the most general renormalizable choice.  [`JetCompleteness.lean:57`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/JetCompleteness.lean#L57) +- Derive `diracEquation`, `diracAdjEquation` and `qedMaxwellEquation` variationally: define the Euler–Lagrange operator on the jet algebra (the variational derivative with respect to each jet coordinate) and prove they are the EL equations of `lagrangian`, following `Physlib.Electromagnetism.Dynamics.IsExtrema` concretely.  [`Lagrangian.lean:119`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L119) +- Define the theta term `θ ε^{μνρσ} F_{μν} F_{ρσ}` and prove it is gauge invariant and a total derivative for `jetDeriv`, as in the lepton–gauge sector's theta term.  [`Lagrangian.lean:123`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L123) +- Quantize: instantiate the field species of `Physlib.QFT.PerturbationTheory` with the photon and electron of this file, towards the Feynman rules of QED.  [`Lagrangian.lean:125`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/Lagrangian.lean#L125) +- Upgrade the mass-weight scaling to a genuine filtration by submodules, following `LeptonGaugeSector.JetAlgebra.MassDim` (`MassWeightLESubmodule`), together with the derivative-order and fermion-parity gradings needed for classification arguments.  [`MassDimension.lean:61`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/QED/MassDimension.lean#L61) + +### `Particles/StandardModel/Fermions/JetAlgebra` + +- Move FermionSpace to a seperate file by itself.  [`Basic.lean:89`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean#L89) +- For FermionSpace define the infinitismal action.  [`Basic.lean:91`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/Fermions/JetAlgebra/Basic.lean#L91) + +### `Particles/StandardModel/GaugeAlgebra` + +- Make the API here match what is in the doc-string.  [`JetGaugeAlgebra.lean:62`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L62) +- Add discussion about the basis.  [`JetGaugeAlgebra.lean:63`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L63) +- Define the basis of the jet gauge algebra.  [`JetGaugeAlgebra.lean:727`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeAlgebra/JetGaugeAlgebra.lean#L727) + +### `Particles/StandardModel/GaugeBosons/BBoson` + +- Show invariance of the mass weights with repsect to the Lorentz group.  [`MassDim.lean:310`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeBosons/BBoson/MassDim.lean#L310) + +### `Particles/StandardModel/GaugeGroup` + +- Define the symmetrized maurerCartan forms.  [`MaurerCartan.lean:59`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan.lean#L59) + +### `Particles/StandardModel/GaugeGroup/MaurerCartan` + +- The below code needs cleaning up and moving to the correct place.  [`Truncation.lean:135`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/GaugeGroup/MaurerCartan/Truncation.lean#L135) + +### `Particles/StandardModel/JetAlgebra` + +- Define the iterated derivative, and show that the iterated derivatives span the adjoin to give the whole algebra.  [`JetDeriv.lean:279`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/StandardModel/JetAlgebra/JetDeriv.lean#L279) + +### `Particles/WessZumino/EFTLagrangianExclDeriv` + +- Define ComplexScalarEFTExclDeriv.rep  [`Basic.lean:280`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Particles/WessZumino/EFTLagrangianExclDeriv/Basic.lean#L280) + +### `Relativity/Fermions/Weyl` + +- Relate `DualLeftHandedWeyl` to `LeftHandedWeyl` via `Module.dual`.  [`DualLeftHanded.lean:35`](https://github.com/jstoobysmith/JTSphyslib/blob/AddPotentialAlgebra/Physlib/Relativity/Fermions/Weyl/DualLeftHanded.lean#L35)